home *** CD-ROM | disk | FTP | other *** search
/ Developer CD Series 1997 October: Mac OS SDK / Dev.CD Oct 97 SDK1.toast / Development Kits (Disc 1) / QuickDraw GX / Programming Stuff / Sample Code / Printing Samples / Printer Drivers… / ImageWriterLQ (alt. rdip) / UniversalMessageIntf.c < prev    next >
Encoding:
Text File  |  1996-06-15  |  86.7 KB  |  2,812 lines  |  [TEXT/MPS ]
  1. /*---------------------------------------------------------------------------
  2. FILENAME
  3.     UniversalMessageIntf.c
  4.  
  5. DESCRIPTION
  6.     This file contains the routines which override the universal imaging 
  7.     messages that the ImageWriter LQ utilizes.
  8.         
  9. COPYRIGHT
  10.     Copyright Apple Computer, Inc. 1992-1994
  11.     All rights reserved. 
  12.     
  13. INTERFACE ROUTINES:
  14.     SD_Initialize
  15.     SD_ShutDown
  16.     SD_JobFormatDialog
  17.     SD_JobFormatModeQuery
  18.     SD_OpenConnection
  19.     SD_StartSendPage
  20.     SD_RenderPage
  21.     SD_DefaultPrinter
  22.     SD_SetupImageData
  23.     SD_FetchTaggedData
  24.     SD_RasterPackageBitmap
  25.     SD_RasterLineFeed
  26.  
  27.     12/20/93        dmh    Sync'd with the shipping 1.0b3 GX driver.
  28.      8/28/94        dmh    Sync'd with the shipping 1.0.1 GX driver.
  29.      8/28/94        dmh    Universalized.
  30.      6/14/96        cn        Updated to support Universal Interfaces 2.1.
  31.  
  32. -------------------------------------------------------------------------------- */
  33.  
  34. // Include the standard Mac header files 
  35. #include "MacIncludes.h"
  36.  
  37. // Include the new QuickDraw GX graphics header files 
  38. #include <GXGraphics.h>
  39. #include <GraphicsLibraries.h>
  40. #include <GXMath.h>
  41. #include <QDLibrary.h>
  42. #include <FontLibrary.h>
  43. #include <GXLayout.h>
  44.  
  45. // Include the required Printing Manager header files 
  46. #include <GXPrinting.h>
  47. #include <GXPrinterDrivers.h>
  48. #include <Collections.h>
  49. #include <GXMessages.h>
  50. #include <PrintingLibraries.h>
  51.  
  52. #include <GXExceptions.h>
  53.  
  54. // Include the internal driver constants and types used by this module 
  55. #include "LQResources.h"
  56. #include "UniversalMessageIntf.h"
  57. #include "OldAPIMessageIntf.h"
  58. #include "DialogRoutines.h"
  59.  
  60. /***************************************************************************************
  61. *                                                 CONSTANTS                                                         *
  62. ***************************************************************************************/                        
  63.  
  64. // ImageWriter LQ device commands
  65.  
  66. #define    kEscape                            (char) 27        // <Escape> character
  67. #define    kLineFeed                        (char) 10        // Line feed character
  68. #define    kDevStatusCommand                "\033?"            // <Escape>? - used to query the status of the printer
  69.  
  70. #define    kLowResGraphicsCommand        (char) 'G'        //    72 dpi graphics mode
  71. #define    kHighResGraphicsCommand        (char) 'C'        //    216 dpi graphics mode
  72.  
  73. #define    kLowResMarginsCommand        (char) 'F'        //    72 dpi margins command
  74. #define    kHighResMarginsCommand        (char) 'h'        //    216 dpi margins command
  75.  
  76. #define    kSetColorCommand                (char) 'K'        //    Command to select color
  77.  
  78.  
  79. // Constants used with the ScanLineRecord structure
  80.  
  81. #define    kScanLineHdrSize                15                    //    Size of the constant portion of the scan line structure
  82.  
  83.  
  84. /***************************************************************************************
  85. *                                                 TYPES                                                                 *
  86. ***************************************************************************************/                        
  87.  
  88. // ScanLineRecord -    Structure overlayed within a buffer to fill in the comands and data needed to
  89. //                            package one complete scan line.
  90. typedef struct
  91. {
  92.     char        cMarginsEscape;            // kEscape character
  93.     char        cMarginsCommand;            // Set Margins command character
  94.     char        cIndentDistance[4];        // Number of pixels to indent
  95.  
  96.     char        cColorEscape;                // kEscape character
  97.     char        cSetColorCommand;            // Set color command
  98.     char        cColor;                        // The color to use
  99.  
  100.     char        cEscape;                        // kEscape character
  101.     char        cCommand;                    // Enter graphics mode command
  102.     char        cLineStrLength[4];            // number of dots to print
  103.     char        iTheData[9072];            // Bits for the data, enough for one line's worth
  104. }    ScanLineRecord,
  105.     *ScanLinePtr;
  106.  
  107.  
  108. /***************************************************************************************
  109. *                                         INTERNAL ROUTINES                                                     *
  110. ***************************************************************************************/                        
  111.  
  112. /****************************************************************************************
  113.  
  114.                             Long2Dec
  115.                             
  116.     function:
  117.                 This routine converts a long integer into an ASCII string representing the
  118.                 numeric value.  If the number is less than four digits, then it's padded
  119.                 with leading zeros.
  120.                 
  121.     parameters:                
  122.                 theNumber            number to convert to a string
  123.                 emitStringHere        location in which to store the ASCII string
  124.                 
  125.     returns:
  126.                 none
  127.     
  128. ****************************************************************************************/
  129. void Long2Dec(long theNumber, Ptr emitStringHere)
  130. {    
  131.     char        aString[10];
  132.     short        i;
  133.     short        actualWidth;
  134.     short        theLength;
  135.     
  136.     NumToString(theNumber, (unsigned char *) aString);
  137.     
  138.     // Get the width of the string, check for being too small
  139.  
  140.     theLength = StrLength(aString);
  141.     actualWidth = theLength;
  142.     if (actualWidth < 4)
  143.         actualWidth = 4;
  144.         
  145.     // output the string, padding with leading zeros
  146.     
  147.     theLength = actualWidth - theLength;
  148.     for (i = 0; i < actualWidth; ++i)
  149.     {
  150.         *emitStringHere++ = (i < theLength) ? '0' : aString[(i + 1) - theLength];
  151.     }
  152. }
  153. /* Long2Dec */
  154.  
  155.  
  156. /****************************************************************************************
  157.  
  158.                             PrinterHasColorRibbon
  159.                             
  160.     function:
  161.                 This routine is a utility function that returns true if the desktop printer
  162.                 configuration file specifies that the printer contains a color ribbon, and
  163.                 false if it has a black and white ribbon.
  164.                 
  165.     parameters:                
  166.                 None
  167.                 
  168.     returns:
  169.                 Boolean        true => printer has color ribbon; false => black and white ribbon
  170.     
  171. ****************************************************************************************/
  172. Boolean PrinterHasColorRibbon(void)
  173. {
  174.     OSErr                        anErr;
  175.     Boolean                    hasColor = true;
  176.     Str32                        deviceName;
  177.     IWLQConfigInfoHdl        configData;
  178.     
  179.     // if not formatting to a particular device, assume color ribbon, for widest range of colorSpaces
  180.  
  181.     GXGetPrinterName(GXGetJobOutputPrinter(GXGetJob()), deviceName);
  182.     if ( StrLength(deviceName) > 0 )
  183.     {
  184.         // if we are going to a particular device, assume no color, as that is more common
  185.         hasColor = false;
  186.         
  187.         anErr = GXFetchDTPData(deviceName, kIWLQConfigType, kIWLQConfigID, (Handle *) &configData);
  188.         if (anErr == noErr)
  189.         {
  190.             hasColor = (*configData)->hasColorRibbon;
  191.             DisposHandle((Handle) configData);
  192.         }
  193.     }
  194.     
  195.     return(hasColor);
  196. }
  197. /* PrinterHasColorRibbon */
  198.  
  199.  
  200. /****************************************************************************************
  201.  
  202.                             PrinterHasTrays
  203.                             
  204.     function:
  205.                 This routine is a utility function that returns the number of sheet feeder trays
  206.                 that are attached to the desktop printer.  If no sheet feeder is attached, then 
  207.                 the function returns zero.
  208.                 
  209.     parameters:                
  210.                 None
  211.                 
  212.     returns:
  213.                 char        number of sheet feeder trays attached to the printer; zero if no sheet feeder
  214.     
  215. ****************************************************************************************/
  216. char PrinterHasTrays(void)
  217. {
  218.     OSErr                        anErr;
  219.     char                        numTrays = 0;    //    Assume no trays available (common case)
  220.     Str32                        deviceName;
  221.     IWLQConfigInfoHdl        configData;
  222.     
  223.     // if not formatting to a particular device, assume color ribbon, for widest range of colorSpaces
  224.  
  225.     GXGetPrinterName(GXGetJobOutputPrinter(GXGetJob()), deviceName);
  226.     if ( StrLength(deviceName) > 0 )
  227.     {
  228.         anErr = GXFetchDTPData(deviceName, kIWLQConfigType, kIWLQConfigID, (Handle *) &configData);
  229.         if (anErr == noErr)
  230.         {
  231.             numTrays = (*configData)->numTrays;
  232.             DisposHandle((Handle) configData);
  233.         }
  234.     }
  235.     
  236.     return(numTrays);
  237. }
  238. /* PrinterHasTrays */
  239.  
  240.  
  241. /****************************************************************************************
  242.  
  243.                             UpdateDTPConfigInfo
  244.                             
  245.     function:
  246.                 This routine is a utility function that queries the printer to determine its
  247.                 configuration (color ribbon, trays, etc.) and updates the config info. in the
  248.                 desktop printer file to reflect this new configuration.
  249.                 
  250.     parameters:                
  251.                 None
  252.                 
  253.     returns:
  254.                 OSErr        error code
  255.     
  256. ****************************************************************************************/
  257. OSErr UpdateDTPConfigInfo(void)
  258. {
  259.     OSErr                        anErr;
  260.     IWLQConfigInfoHdl        configData;
  261.     char                        statusString[9];
  262.     long                        statusStrLength;
  263.     Boolean                    wasSheetfeederAttached;
  264.     gxJob                        theJob = GXGetJob();
  265.         
  266.     // Determine if there was a sheetfeeder attached to the printer the last time we updated the config file
  267.     wasSheetfeederAttached = PrinterHasTrays() > 0;
  268.     
  269.     // Make a handle in which to store the config. info.
  270.     
  271.     configData = (IWLQConfigInfoHdl) NewHandleClear( sizeof(IWLQConfigInfo) );
  272.     anErr = MemError();
  273.     require(anErr == noErr, NewHandleClear);
  274.     
  275.     // Now query the printer
  276.     
  277.     statusStrLength = 9;
  278.     
  279.     anErr = Send_GXGetDeviceStatus(kDevStatusCommand, 2, statusString, &statusStrLength, "\p\n");
  280.     require(anErr == noErr, Send_GXGetDeviceStatus);
  281.     
  282.     // Scan the status string returned looking for the needed info.
  283.     
  284.     if ( (statusString[0] == 'L') && (statusString[1] == 'Q') )
  285.     {
  286.         Str32        deviceName;
  287.  
  288.         if ( statusString[3] == 'C' )    //    T => Has color ribbon
  289.         {
  290.             (*configData)->hasColorRibbon = true;
  291.         }
  292.         
  293.         if (  (statusString[3] == 'E') || 
  294.                 (statusString[3] == 'F')
  295.             )                                            //    T => Sheet feeder is installed
  296.         {
  297.             (*configData)->numTrays = statusString[4] - 0x30;
  298.         }
  299.         else
  300.         if (    (statusString[4] == 'E') ||
  301.                 (statusString[4] == 'F')
  302.             )                                            //    T => Sheet feeder is installed
  303.         {
  304.             (*configData)->numTrays = statusString[5] - 0x30;
  305.         }
  306.  
  307.         //    Update the config. file with the latest info. (our driver info.)
  308.         
  309.         GXGetPrinterName(GXGetJobOutputPrinter(theJob), deviceName);
  310.         anErr = GXWriteDTPData(deviceName, kIWLQConfigType, kIWLQConfigID, (Handle) configData);
  311.         require(anErr == noErr, WriteDTPData);
  312.  
  313.         // If this is the first time we've detected a sheet feeder, then we must set the tray info. (in the config. file)
  314.         // for the sheet feeder trays.  If this isn't the first time we've detected a sheetfeeder, we'll just use
  315.         // the last sheetfeeder tray settings.
  316.         
  317.         if ( (!wasSheetfeederAttached) && ((*configData)->numTrays > 0) )    //    T => No sheetfeeder before; clear the tray info.
  318.         {
  319.             GXSetTrayPaperType(1, NULL);    /* Reset the paper types from the default tray */
  320.         }
  321.         else if ( wasSheetfeederAttached && ((*configData)->numTrays == 0) )    //    T => Sheetfeeder before; clear the tray info.
  322.         {
  323.             GXSetTrayPaperType(1, NULL);    /* Reset the paper types from the first tray, ignore the others */
  324.         }
  325.     }
  326.     // else - not an LQ printer so don't change the config file info.
  327.  
  328.     // Dump the confog. data handle
  329.     DisposHandle((Handle) configData);
  330.  
  331.     return(anErr);
  332.     
  333.     
  334. /******* Clean-up *******/
  335.  
  336. WriteDTPData:
  337. Send_GXGetDeviceStatus:
  338.     DisposHandle((Handle) configData);
  339.     
  340. NewHandleClear:
  341.     return(anErr);
  342. }
  343. /* UpdateDTPConfigInfo */
  344.  
  345.  
  346. /****************************************************************************************
  347.  
  348.                             FixRoundRectangle
  349.                             
  350.     function:
  351.                 This routine is a utility function which rounds the coordinate values within 
  352.                 the rectangle passed in.
  353.                 
  354.     parameters:                
  355.                 r            rectangle whose coordinates are to be rounded
  356.                 
  357.     returns:
  358.                 None
  359.     
  360. ****************************************************************************************/
  361. void FixRoundRectangle(gxRectangle *r)
  362. {
  363.     r->top         = ff(FixRound(r->top));
  364.     r->left         = ff(FixRound(r->left));
  365.     r->bottom     = ff(FixRound(r->bottom));
  366.     r->right     = ff(FixRound(r->right));
  367. }
  368. /* FixRoundRectangle */
  369.  
  370.  
  371. /****************************************************************************************
  372.  
  373.                             JobIsBestQuality
  374.                             
  375.     function:
  376.                 This routine is called to determine if the job the driver is currently
  377.                 processing is to be output in best quality or rough quality. The function
  378.                 returns true if best quality, and false otherwise.
  379.                 
  380.     parameters:    
  381.                 None
  382.                 
  383.     returns:
  384.                 Boolean        true if best quality job; false otherwise
  385.     
  386. ****************************************************************************************/
  387. Boolean JobIsBestQuality(void)
  388. {
  389.     OSErr                    anErr;
  390.     Boolean                isFinal;
  391.     gxQualityInfo        jobQualitySettings;
  392.     long                    itemSize = sizeof(jobQualitySettings);
  393.  
  394.     // Retrieve the quality setting info from the job
  395.     anErr = GetCollectionItem(GXGetJobCollection(GXGetJob()), gxQualityTag, gxPrintingTagID, &itemSize, &jobQualitySettings);
  396.     check(anErr == noErr);
  397.     
  398.     isFinal = (anErr == noErr) && (jobQualitySettings.currentQuality == 1);
  399.  
  400.     return(isFinal);
  401. }
  402. /* JobIsBestQuality */
  403.  
  404.  
  405. /****************************************************************************************
  406.  
  407.                             MakeNewPrinterViewDevice
  408.                             
  409.     function:
  410.                 This routine is called to add a new view device to the printer object.  The
  411.                 viewDevice that's added will have a resolution of 216 dpi, and will have the
  412.                 set of colors specified by the theColors parameter.  The newly created 
  413.                 view device is added to the printer object.
  414.                 
  415.     parameters:                
  416.                 thePrinter        the newly allocated printer object
  417.                 theColors        the colors over which the view device is defined
  418.                 numColrs            the number of colors in the set
  419.                 
  420.     returns:
  421.                 OSErr
  422.                 
  423. ****************************************************************************************/
  424. OSErr MakeNewPrinterViewDevice(    gxPrinter        thePrinter,
  425.                                             gxSetColor        theColors[],
  426.                                             short                numColors)
  427. {
  428.     OSErr             anErr = noErr;
  429.     gxViewDevice     vd;
  430.     gxMapping        vdMapping;
  431.     gxShape            theBitmap;
  432.     gxColorSet        theColorSet;
  433.     
  434.     // Create the new viewDevice using a fake bitmap 
  435.     {
  436.         gxBitmap    aBitmap;
  437.         
  438.         aBitmap.pixelSize    = 1;
  439.         aBitmap.rowBytes    = 0;
  440.         aBitmap.width        = 0;
  441.         aBitmap.height        = 0;
  442.         aBitmap.image        = (char*)gxMissingImagePointer;
  443.         aBitmap.space        = gxNoSpace;
  444.         aBitmap.set            = nil;
  445.         aBitmap.profile    = nil;
  446.         
  447.         theBitmap = GXNewBitmap(&aBitmap, nil);
  448.         require_action( GXGetGraphicsError(nil) == noErr, NewBitmap, anErr = GXGetGraphicsError(nil); );
  449.         
  450.         vd = GXNewViewDevice(gxScreenViewDevices, theBitmap);
  451.         require_action( GXGetGraphicsError(nil) == noErr, NewViewDevice, anErr = GXGetGraphicsError(nil); );
  452.  
  453.         // Dispose of the reference to the temporary shape
  454.         GXDisposeShape(theBitmap);
  455.     }
  456.     
  457.     // Now set the view device's color space based on the set of colors passed in 
  458.     {
  459.         theColorSet = GXNewColorSet(gxRGBSpace, numColors, theColors);
  460.         require_action( GXGetGraphicsError(nil) == noErr, NewColorSet, anErr = GXGetGraphicsError(nil); );
  461.  
  462.         SetViewDeviceColorSet(vd, theColorSet);
  463.         require_action( GXGetGraphicsError(nil) == noErr, SetViewDeviceColorSet, anErr = GXGetGraphicsError(nil); );
  464.     
  465.         // Dispose of the reference to the temporary shape
  466.         GXDisposeColorSet(theColorSet);
  467.     }
  468.     
  469.     // Change the viewDevice mapping to include the scaling factor from 72dpi (screen) to 216 dpi (device). 
  470.     {
  471.         ResetMapping(&vdMapping);
  472.         ScaleMapping(&vdMapping, ff(3), ff(3), ff(0), ff(0));
  473.         
  474.         GXSetViewDeviceMapping(vd, &vdMapping);
  475.     }
  476.     
  477.     // Add the newly created viewDevice to the printer object 
  478.  
  479.     anErr = GXAddPrinterViewDevice(thePrinter, vd);
  480.     require_action( GXGetGraphicsError(nil) == noErr, AddPrinterViewDevice, anErr = GXGetGraphicsError(nil); );
  481.     
  482.     return(anErr);
  483.     
  484.     
  485. /******* Clean-up *******/
  486.  
  487. SetViewDeviceColorSet:
  488.     GXDisposeColorSet(theColorSet);
  489.  
  490. AddPrinterViewDevice:
  491. NewColorSet:
  492.     GXDisposeViewDevice(vd);
  493.     return(anErr);
  494.  
  495. NewViewDevice:
  496.     GXDisposeShape(theBitmap);
  497.  
  498. NewBitmap:
  499.     return(anErr);
  500. }
  501. /* MakeNewPrinterViewDevice */
  502.  
  503.  
  504. /****************************************************************************************
  505.  
  506.                             WriteDraftChars
  507.                             
  508.     function:
  509.                 This routine is called to output a single character in the native set of the
  510.                 printer.  The draftTable parameter contains long word entries for each possible
  511.                 character that can be printed.  Each long word entry is composed of two word entries,
  512.                 where the first word represents the primary character to output and the second
  513.                 word optionally specifies an overstrike character.  If an overstrike character
  514.                 is specified, then we will overstrike the second character on the first.  The format
  515.                 of each word is the same and is as follows:
  516.                 
  517.                 bit 15         -    0 => don't backspace before writing character
  518.                                     1 => backspace first before printing the character
  519.                 
  520.                 bits 14:12    -    0
  521.  
  522.                 bits 11:8    -    national character set to invoke (e.g. kAmerican)
  523.  
  524.                 bits 7:0        -    the character to send to the printer (must be != 0 to be output)
  525.                 
  526.     parameters:    
  527.                 draftTable        Handle to an array of long word entries that describe how to output
  528.                                     each printable character in draft mode
  529.                 draftChar        Pointer to the ASCII characters that are to be output
  530.                 numChars            Number of characters to be output
  531.                 
  532.     returns:
  533.                 OSErr
  534.     
  535. ****************************************************************************************/
  536. OSErr WriteDraftChars(long **draftTable, unsigned char *draftChar, long numChars)
  537. {
  538.     OSErr        anErr = noErr;
  539.     char        outputChars[20];                // a maximum of 20 characters can be generated
  540.     short        charCount;                    
  541.     
  542.     // For each character in the buffer, determine how to map the character to a draft character
  543.     for (; numChars > 0; --numChars, ++draftChar)
  544.     {
  545.         // No characters yet for this output character
  546.         charCount = 0;
  547.             
  548.         // Only consider characters in the printable range
  549.         if (*draftChar >= 0x20)
  550.         {
  551.             unsigned long    draftControl = (*draftTable)[*draftChar-0x20];    // Fetch native mode long word corresponding to this character
  552.             unsigned char    outChar;
  553.             unsigned char    nationalSet;
  554.             short                i;
  555.             
  556.             // For each word which composes the native mode long word 
  557.             for (i = 1; i >= 0; --i)
  558.             {
  559.                 // Should we send a backspace character (to overstrike)?
  560.                 if ( (draftControl & 0x80000000) != 0 )
  561.                     outputChars[charCount++] = 0x08;
  562.                 
  563.                 outChar = (draftControl >> 16) & 0xFF;
  564.                 if (outChar != 0)
  565.                 {
  566.                     // Determine the national character set to select
  567.                     nationalSet = (draftControl >> 24) & 0xF;    
  568.     
  569.                     //    Is this character in the standard, built-in character set?
  570.                     if (nationalSet == kAmerican)
  571.                     {
  572.                         outputChars[charCount++] = outChar;
  573.                     }
  574.                     else    //    T => Must select a foreign language character set 
  575.                     {
  576.                         outputChars[charCount++] = 0x1B;
  577.                         outputChars[charCount++] = 0x44;
  578.                         outputChars[charCount++] = nationalSet;
  579.                         outputChars[charCount++] = 0x00;
  580.                         outputChars[charCount++] = outChar;
  581.                         outputChars[charCount++] = 0x1B;                // We always switch back to the kAmerican character set
  582.                         outputChars[charCount++] = 0x5A;
  583.                         outputChars[charCount++] = 0x07;
  584.                         outputChars[charCount++] = 0x00;
  585.                     }
  586.                 }
  587.                 
  588.                 // Take the next (low) word and process it (if we're not all done)
  589.                 draftControl <<= 16;
  590.             }    
  591.         }
  592.             
  593.         // If we generated any data, send it out now
  594.         if (charCount > 0)
  595.             anErr = Send_GXBufferData(outputChars, charCount, gxNoBufferOptions);
  596.     }
  597.         
  598.     return(anErr);    
  599.     
  600. } 
  601. /* WriteDraftChars */
  602.  
  603.  
  604. /****************************************************************************************
  605.  
  606.                             GetPointerThisBig
  607.                             
  608.     function:
  609.                 This routine is called to return a pointer (in the heap) to the number of
  610.                 bytes specified by numBytes.  If the pointer is already large enough, then
  611.                 this routine simply returns the existing pointer.  Otherwise, it allocates
  612.                 a new pointer (possibly disposing of the old one) of the specified size.
  613.                 
  614.     parameters:    
  615.                 theBuff            returns a pointer to the allocated buffer 
  616.                 numBytes            required size of the pointer returned (in bytes)
  617.                 
  618.     returns:
  619.                 OSErr
  620.     
  621. ****************************************************************************************/
  622. OSErr GetPointerThisBig(Ptr *theBuff, long numBytes) 
  623. {
  624.     OSErr        anErr = noErr;
  625.     
  626.     if (*theBuff != nil)
  627.     {
  628.         if ( GetPtrSize(*theBuff) < numBytes )    //    T => Won't be big enough; make a new one
  629.         {
  630.             DisposPtr(*theBuff);
  631.             *theBuff = nil;
  632.         }
  633.     }
  634.  
  635.     if (*theBuff == nil)
  636.     {
  637.         *theBuff = NewPtrClear(numBytes);
  638.         anErr = MemError();
  639.     }
  640.     
  641.     return(anErr);
  642. }
  643. /* GetPointerThisBig */
  644.  
  645.  
  646. /****************************************************************************************
  647.  
  648.                             GetTextAndPosition
  649.                             
  650.     function:
  651.                 This routine is called to return information about the layout shape
  652.                 referenced by the theShape parameter.  It returns a pointer to the
  653.                 text data in theChars, the number of characters in the data in numChars, and
  654.                 a pointer to the positions of the characters in textPositions.  The caller
  655.                 is responsible for disposing of the pointers returned in theChars and
  656.                 textPositions.
  657.                 
  658.     parameters:    
  659.                 theShape            reference to the shape to be examined
  660.                 theChars            returns a pointer to the text characters
  661.                 numChars            returns the number of characters in the text shape
  662.                 textPosition    returns the position of the layout shape
  663.                 
  664.     returns:
  665.                 OSErr
  666.     
  667. ****************************************************************************************/
  668. OSErr GetTextAndPosition(    gxShape            theShape, 
  669.                                     Ptr            *theChars, 
  670.                                     long            *numChars, 
  671.                                     gxPoint            *textPosition)
  672. {
  673.     OSErr        anErr = noErr;
  674.     long        textStrLength;
  675.     
  676.     // Determine the size of the text data and the position of the text
  677.     textStrLength = GXGetLayout(theShape, nil, nil, nil, nil, nil, nil, nil, nil, textPosition);
  678.  
  679.     // Make sure we have a buffer pointer large enough to hold all of the data
  680.     
  681.     anErr = GetPointerThisBig(theChars, textStrLength);
  682.     require(anErr == noErr, CantAllocTextBuff);
  683.     
  684.     // Now we retrieve the text
  685.     GXGetLayout(theShape, *theChars, nil, nil, nil, nil, nil, nil, nil, nil);
  686.     
  687.     // Remember the number of characters in the shape
  688.     *numChars = textStrLength;
  689.     
  690.  
  691. /******* Clean-up *******/
  692.  
  693. CantAllocTextBuff:
  694.     return(anErr);
  695. }
  696. /* GetTextAndPosition */
  697.  
  698.  
  699. /****************************************************************************************
  700.  
  701.                             PrintPageInDraftMode
  702.                             
  703.     function:
  704.                 This routine is called to print a page using the native character set in the
  705.                 printer.  The page to print is referenced by the thePage parameter.  The routine
  706.                 walks through the picture looking for layout shapes.  Each of these
  707.                 shapes is imaged using the native character set; all other shapes are ignored.
  708.                 This routine assumes the shapes within the picture are y-sorted.
  709.                 
  710.     parameters:    
  711.                 thePage        Reference to the page shape that's to be printed
  712.                 imageData    pointer to the raster image data
  713.                 
  714.     returns:
  715.                 OSErr
  716.     
  717. ****************************************************************************************/
  718. OSErr PrintPageInDraftMode(gxShape thePage, gxRasterImageDataHdl imageData)
  719. {
  720.     OSErr                    anErr = noErr;
  721.     long                    i;
  722.     long                    numItems;
  723.     Fixed                    currYPos = ff(0);
  724.     Ptr                    theChars = nil;
  725.     long                    numChars = 0;
  726.     gxPoint                textPosition;
  727.     Fixed                    oldTextSize = ff(0);
  728.     SpecGlobalsHdl     hGlobals = GetMessageHandlerInstanceContext();
  729.     
  730.     // Since the page picture we need to process is a picture shape that's embedded in
  731.     // thePage (a shape containing one item => a picture), we need to extract the real
  732.     // page picture from thePage.
  733.     
  734.     thePage = GetPictureItem(thePage, 1, nil, nil, nil, nil);
  735.     numItems = GXGetPicture(thePage, nil, nil, nil, nil);
  736.     
  737.     // For each shape within the picture, check its type and process it accordingly
  738.     
  739.     for (i = 1; i <= numItems; ++i)
  740.     {
  741.         gxShape                theShape;
  742.         short                    theType;
  743.         
  744.         theShape = GetPictureItem(thePage, i, nil, nil, nil, nil);
  745.         theType = GXGetShapeType(theShape);
  746.         
  747.         if (theType == gxLayoutType)    //    T => We have a layout shape
  748.         {
  749.             Fixed        textSize;
  750.             char        buff[12];
  751.             char        theFace;
  752.             short        cmndBuffSz;
  753.             
  754.             // First determine the style in which we're printing
  755.             
  756.             theFace = GetStyleCommonFace( GXGetShapeStyle(theShape) );
  757.             
  758.             buff[0] = kEscape;
  759.             if ( (theFace & bold) != 0 )    //    T => Turn bold facing on
  760.                 buff[1] = '!';
  761.             else                                    //    T => Turn it off
  762.                 buff[1] = '"';
  763.             
  764.             buff[2] = kEscape;
  765.             if ( (theFace & underline) != 0 )    //    T => Turn underline facing on
  766.                 buff[3] = 'X';
  767.             else                                            //    T => Turn it off
  768.                 buff[3] = 'Y';
  769.                 
  770.             cmndBuffSz = 4;
  771.             
  772.             // Next determine if we need to change the size of the font being used
  773.             
  774.             textSize = GXGetShapeTextSize(theShape);
  775.             if (textSize != oldTextSize)    //    T => Must issue LQ command to change font size
  776.             {
  777.                 buff[4] = kEscape;                //    The first escape command selects black color
  778.                 buff[5] = kSetColorCommand;
  779.                 buff[6] = '0';
  780.                 
  781.                 buff[7] = kEscape;                //    The second escape command selects a draft font
  782.                 buff[8] = 'a';
  783.                 buff[9] = '1';
  784.                 
  785.                 buff[10] = kEscape;                //    The third escape command selects the character pitch
  786.                 
  787.                 if ( textSize <= ff(10) )    //    T => Select 10 cpi
  788.                 {
  789.                     buff[11] = 'N';
  790.                 }
  791.                 else    //    T => All other sizes get mapped to 12 cpi
  792.                 {
  793.                     buff[11] = 'E';
  794.                 }
  795.                 
  796.                 // Remember the last text size
  797.                 oldTextSize = textSize;    
  798.                 
  799.                 // Adjust the size of the data to be sent to the printer
  800.                 cmndBuffSz += 8;
  801.             }
  802.             // else - no change in font size
  803.             
  804.             // Send the commands to the printer
  805.             anErr = Send_GXBufferData(buff, cmndBuffSz, gxDontSplitBuffer);
  806.             require(anErr == noErr, CantSendFontCmnd);
  807.  
  808.             // Get the ASCII text and the starting position of the data
  809.             anErr = GetTextAndPosition(theShape, &theChars, &numChars, &textPosition);
  810.             require(anErr == noErr, CantGetTextAndPos);
  811.             
  812.             if ( (currYPos != ff(0)) && (currYPos != textPosition.y) )    //    T => Moving to a lower line, finish the last ;line with a CR
  813.             {
  814.                 char        c = 0x0D;
  815.                 
  816.                 anErr = Send_GXBufferData(&c, 1, gxNoBufferOptions);
  817.                 require(anErr == noErr, CantSendCRCmnd);
  818.             }
  819.             
  820.             // Position the print head to the proper location on the page
  821.             {
  822.                 gxMapping            theMapping;
  823.                 long                    lineFeedSize;
  824.                 Str255                positionCmndsBuff;
  825.                 unsigned long        bytesInBuff = 0;
  826.                 char                    *p;
  827.  
  828.                 GXGetShapeMapping(theShape, &theMapping);
  829.                 MapPoints(&theMapping, (long) 1, &textPosition);    //    Just map the first point
  830.                 
  831.                 // Now position the print head vertically
  832.  
  833.                 lineFeedSize = (textPosition.y - currYPos) >> 16;
  834.                 anErr = Send_GXRasterLineFeed(&lineFeedSize, (char *) positionCmndsBuff, &bytesInBuff, imageData);
  835.                 require(anErr == noErr, CantEmitLineFeeds);
  836.                 
  837.                 // Update the current Y position pointer on the page
  838.                 currYPos = textPosition.y;
  839.  
  840.                 // Now position the print head horizontally on the page
  841.  
  842.                 p = (char *) &positionCmndsBuff[bytesInBuff];        
  843.                 *p++ = kEscape;
  844.                 *p++ = kLowResMarginsCommand;
  845.                 Long2Dec((*hGlobals)->leftMargin + FixedToInt(textPosition.x), p);    // Convert left margin into ASCII and place it at the start of the scan line
  846.                 
  847.                 // Update the number of bytes in the buffer
  848.                 bytesInBuff += 6;
  849.  
  850.                 // Send the positioning info to the printer
  851.                 anErr = Send_GXBufferData((char *) positionCmndsBuff, bytesInBuff, gxDontSplitBuffer);
  852.                 require(anErr == noErr, CantSendPositionCmnds);
  853.             }
  854.             
  855.             // Now we send the text data to the printer
  856.             anErr = WriteDraftChars((long **) (*hGlobals)->draftTable, (unsigned char *) theChars, numChars);
  857.             require(anErr == noErr, CantWriteChars);
  858.         }
  859.     }    // for
  860.  
  861.     // Send one last CR to wrap the last line (if there was one)
  862.     {
  863.         char        c = 0x0D;
  864.         
  865.         anErr = Send_GXBufferData(&c, 1, gxNoBufferOptions);
  866.     }
  867.  
  868.  
  869. /******* Clean-up *******/
  870.  
  871. CantWriteChars:
  872. CantSendPositionCmnds:
  873. CantEmitLineFeeds:
  874. CantSendCRCmnd:
  875. CantGetTextAndPos:
  876. CantSendFontCmnd:
  877.     if (theChars != nil)
  878.         DisposPtr(theChars);
  879.                 
  880.     return(anErr);
  881. }
  882. /* PrintPageInDraftMode */
  883.  
  884.  
  885. /***************************************************************************************
  886. *                                         INTERFACE ROUTINES                                                     *
  887. ***************************************************************************************/                        
  888.  
  889. /****************************************************************************************
  890.  
  891.                             SD_Initialize
  892.                             
  893.     function:
  894.                 This routine is called when a new job is created to perform some job-oriented
  895.                 task, such as conducting dialogs, spooling, and imaging.  It allocates the
  896.                 driver's globals handle and initializes it.
  897.                 
  898.     parameters:    
  899.                 None
  900.                 
  901.     returns:
  902.                 OSErr
  903.     
  904. ****************************************************************************************/
  905. OSErr SD_Initialize(void)
  906. {
  907.     OSErr                 anErr;
  908.     SpecGlobalsHdl     hGlobals;
  909.     
  910.     // Allocate the driver's global handle 
  911.  
  912.     hGlobals = (SpecGlobalsHdl) NewHandleClear(kSpecGlobalsRecLen);
  913.     anErr = MemError();
  914.     require(anErr == noErr, NewHandleClear);
  915.     
  916.     // Tell the Printing Manager to save our globals handle for us 
  917.     SetMessageHandlerInstanceContext(hGlobals);
  918.  
  919.     return(anErr);
  920.     
  921.     
  922. /******* Clean-up *******/
  923.  
  924. NewHandleClear:
  925.     return(anErr);
  926. }
  927. /* SD_Initialize */
  928.  
  929.  
  930. /****************************************************************************************
  931.  
  932.                             SD_ShutDown
  933.                             
  934.     function:
  935.                 This routine is called when a job-oriented task has completed and the 
  936.                 message chain is being destroyed.  This routine disposes of the driver's
  937.                 globals handle..
  938.                 
  939.     parameters:        
  940.                 None
  941.                 
  942.     returns:
  943.                 OSErr
  944.     
  945. ****************************************************************************************/
  946. OSErr SD_ShutDown(void)
  947. {
  948.     SpecGlobalsHdl hGlobals = GetMessageHandlerInstanceContext();
  949.     
  950.     // Dump the draft table if we loaded it
  951.     if ( (*hGlobals)->draftTable != nil )
  952.         DisposHandle((*hGlobals)->draftTable);
  953.     
  954.     // Dump the driver's globals handle if it was allocated 
  955.     if (hGlobals != nil)
  956.         DisposHandle((Handle) hGlobals);
  957.  
  958.     // Make sure the Printing Manager no longer has a reference to our globals handle 
  959.     SetMessageHandlerInstanceContext(nil);
  960.         
  961.     return(noErr);
  962. }
  963. /* SD_ShutDown */
  964.  
  965.  
  966. /****************************************************************************************
  967.  
  968.                             SD_JobFormatDialog
  969.                             
  970.     function:
  971.                 This routine is called when the Printing Manager is called to display the
  972.                 Job Format dialog.  This message gives the driver the opportunity to determine
  973.                 the job format modes that are supported by the application.  If the application
  974.                 supports text, then we set the preferred job format mode to be 'text'.  The preferred
  975.                 format mode is the format mode that becomes active when the user selects Direct
  976.                 Mode from the Job Format dialog box.
  977.                 
  978.     parameters:                
  979.                 dlgResult        result of dismissing the dialog (ok or cancel)
  980.                 
  981.     returns:
  982.                 OSErr
  983.                 
  984. ****************************************************************************************/
  985. OSErr SD_JobFormatDialog(gxDialogResult *dlgResult)
  986. {
  987.     OSErr                         anErr;
  988.     gxJobFormatModeTableHdl    theJobFormatModeList;
  989.     gxJob                             theJob = GXGetJob();
  990.     
  991.     // Did the application specify any job format modes?
  992.     
  993.     anErr = GXGetAvailableJobFormatModes(&theJobFormatModeList);
  994.     if ( (anErr == noErr) && (theJobFormatModeList != nil) )
  995.     {
  996.         long    i;
  997.  
  998.         // Examine each job format mode to determine if 'text' mode is supported.  If
  999.         // it is, then we make it the preferred format mode for Direct Mode printing
  1000.         
  1001.         for (i = 0; i <= (*theJobFormatModeList)->numModes - 1; ++i) 
  1002.         {
  1003.             if ((*theJobFormatModeList)->modes[i] == gxTextJobFormatMode) 
  1004.             {
  1005.                 // Tell Printing Manger we support 'text' Direct Mode, but that we also
  1006.                 // support other modes.
  1007.                 
  1008.                 GXSetPreferredJobFormatMode(gxTextJobFormatMode, false);
  1009.                 break;
  1010.             }
  1011.         }
  1012.         
  1013.         // Dump the temporary handle we were issued
  1014.         DisposHandle((Handle)theJobFormatModeList);
  1015.     }
  1016.         
  1017.     // New we let the dialog be displayed. 
  1018.  
  1019.     anErr = Forward_GXJobDefaultFormatDialog(dlgResult);
  1020.     require(anErr == noErr, Forward_GXJobFormatDialog);
  1021.     
  1022.     return(anErr);
  1023.     
  1024.     
  1025. /******* Clean-up *******/
  1026.  
  1027. Forward_GXJobFormatDialog:
  1028.     return(anErr);
  1029. }
  1030. /* SD_JobFormatDialog */
  1031.  
  1032.  
  1033. /****************************************************************************************
  1034.  
  1035.                             SD_JobPrintDialog
  1036.                             
  1037.     function:
  1038.                 This routine is called when the Printing Manager is called to display the
  1039.                 Job dialog.  This message gives the driver the opportunity to add the LQ Options
  1040.                 panel to the dialog.  This panel provides the user the option to choose between
  1041.                 bidirectional and unidirectional printing.
  1042.                 
  1043.     parameters:                
  1044.                 dlgResult        result of dismissing the dialog (ok or cancel)
  1045.                 
  1046.     returns:
  1047.                 OSErr
  1048.                 
  1049. ****************************************************************************************/
  1050. OSErr SD_JobPrintDialog(gxDialogResult *dlgResult)
  1051. {
  1052.     OSErr                     anErr;
  1053.     gxPanelSetupRecord    thePanelInfo;
  1054.     long                        headMotionSize;
  1055.     Collection                jobCollection;
  1056.     HeadMotionJobItem        theMotion;
  1057.         
  1058.     // Get a reference to the job's collection
  1059.     jobCollection = GXGetJobCollection( GXGetJob() );
  1060.     
  1061.     // See if the head motion collection item exists.  It the item already exists, then
  1062.     // we'll use the last settings.
  1063.  
  1064.     headMotionSize = sizeof(HeadMotionJobItem);
  1065.     anErr = GetCollectionItem (jobCollection,
  1066.                                         kDrvrCreatorType, 
  1067.                                         kHeadMotionItemIndex, 
  1068.                                            &headMotionSize,
  1069.                                            &theMotion);
  1070.                                         
  1071.     if (anErr == collectionItemNotFoundErr)    // T => Item doesn't exist; add it
  1072.     {
  1073.         theMotion.direction = doUnidirectional;
  1074.         
  1075.         anErr = AddCollectionItem(    jobCollection, 
  1076.                                             kDrvrCreatorType, 
  1077.                                             kHeadMotionItemIndex, 
  1078.                                             sizeof(HeadMotionJobItem),
  1079.                                             &theMotion);
  1080.         require(anErr == noErr, AddCollectionItem);
  1081.     }
  1082.     else
  1083.         require(anErr == noErr, CantGetCollection);
  1084.  
  1085.     // Before allowing the Printing Manager to display the dialog, we must first add
  1086.     // our panel to the dialog.  We do this by appropriately filling in the PanelSetupRecord
  1087.     // and then telling the Printing Manager to add our panel to the dialog.
  1088.     
  1089.     // Initialize the dialog panel structure
  1090.     thePanelInfo.panelResId            = kLQOptionsPanl;        //    Resource ID of the 'panl' resource
  1091.     thePanelInfo.resourceRefNum    = GXGetMessageHandlerResFile();
  1092.     thePanelInfo.refCon                = 0;
  1093.     thePanelInfo.panelKind            = gxDriverPanel;
  1094.     
  1095.     // Add the dialog panel to the Print dialog
  1096.     
  1097.     GXSetupDialogPanel(&thePanelInfo);
  1098.     anErr = GXGetJobError( GXGetJob() );
  1099.     require(anErr == noErr, SetupDialogPanel);
  1100.  
  1101.     // Now we let the dialog be displayed. 
  1102.  
  1103.     anErr = Forward_GXJobPrintDialog(dlgResult);
  1104.     check(anErr == noErr);
  1105.     
  1106.     
  1107. /******* Clean-up *******/
  1108.  
  1109. Forward_GXJobPrintDialog:
  1110. SetupDialogPanel:
  1111. CantGetCollection:
  1112. AddCollectionItem:
  1113.     return(anErr);
  1114. }
  1115. /* SD_JobPrintDialog */
  1116.  
  1117.  
  1118. /****************************************************************************************
  1119.  
  1120.                             SD_JobFormatModeQuery
  1121.                             
  1122.     function:
  1123.                 This routine is called when an application calls JobFormatModeQuery to determine
  1124.                 the format modes that are available from the driver.  This message gives the 
  1125.                 driver the opportunity to determine the type of format mode query the driver
  1126.                 is requesting and responds to it with the appropriate data.
  1127.                 
  1128.     parameters:                
  1129.                 theQuery        type of query to perform
  1130.                 srcData        source data (varies depending upon the type of query)
  1131.                 dstData        destination data (varies depending upon the type of query)
  1132.                 
  1133.     returns:
  1134.                 OSErr
  1135.                 
  1136. ****************************************************************************************/
  1137. OSErr SD_JobFormatModeQuery(gxQueryType theQuery, void *srcData, void *dstData)
  1138. {
  1139.     OSErr        anErr = noErr;
  1140.     Handle    theFonts;
  1141.     Handle    theStyles;
  1142.     
  1143.     check(dstData != nil);
  1144.     
  1145.     // What type of query is being requested?
  1146.     switch(theQuery) 
  1147.     {
  1148.         case gxSetStyleJobFormatCommonStyleQuery:
  1149.         {
  1150.             char                *pStyleName;
  1151.  
  1152.             // Fetch the list of supported styles
  1153.             
  1154.             anErr = Send_GXFetchTaggedDriverData('STR#', kFormatModeStylesID, &theStyles);
  1155.             require(anErr == noErr, FailedToLoadStyles1);
  1156.             
  1157.             HNoPurge(theStyles);
  1158.             HLock(theStyles);
  1159.             
  1160.             // Determine which style is being referenced and set the corresponding style (only 2 styles
  1161.             // are currently supported)
  1162.             
  1163.             if (**((short **) theStyles) == 2)    //    T => We have the correct number of styles
  1164.             {
  1165.                 char        whichFace = 0;
  1166.                 
  1167.                 pStyleName = ((char *) *theStyles) + sizeof(short); 
  1168.                 
  1169.                 if ( IUCompString((unsigned char const *) pStyleName, (unsigned char const *) srcData) == 0 )    //    T => They want bold face
  1170.                 {
  1171.                     whichFace = bold;
  1172.                 }
  1173.                 else
  1174.                 {
  1175.                     // Point to the next name in the list
  1176.                     pStyleName += *pStyleName + 1;
  1177.  
  1178.                     if ( IUCompString((unsigned char const *) pStyleName, (unsigned char const *) srcData) == 0 )    //    T => They want underline face
  1179.                     {
  1180.                         whichFace = underline;
  1181.                     }
  1182.                 }
  1183.  
  1184.                 //    If the client specified a valid face, set it now
  1185.                 if (whichFace != 0)
  1186.                 {
  1187.                     SetStyleCommonFace((gxStyle) dstData, GetStyleCommonFace((gxStyle) dstData) | whichFace);
  1188.                 }
  1189.             }
  1190.             // else - something is wrong with our resource
  1191.             
  1192.             // Dump the temporary handle
  1193.             DisposHandle(theStyles);
  1194.             
  1195.             break;
  1196.         }
  1197.             
  1198.         case gxGetJobFormatFontCommonStylesQuery:
  1199.         {
  1200.             short                numStyles;
  1201.             short                i;
  1202.             char                *pStyleName;
  1203.  
  1204.             // Fetch the list of supported styles
  1205.             
  1206.             anErr = Send_GXFetchTaggedDriverData('STR#', kFormatModeStylesID, &theStyles);
  1207.             require(anErr == noErr, FailedToLoadStyles2);
  1208.             
  1209.             HNoPurge(theStyles);
  1210.             HLock(theStyles);
  1211.             
  1212.             // Determine the number of styles in the list
  1213.             numStyles = **((short **) theStyles);
  1214.  
  1215.             if (*(Handle *)dstData != nil)    //    T => Resize the handle to hold info. on the styles
  1216.                 SetHandleSize(*(Handle *)dstData, sizeof(gxStyleNameTable) + ((numStyles - 1) * sizeof(Str255)));
  1217.             else
  1218.                 *(Handle *)dstData = NewHandle(sizeof(gxStyleNameTable) + ((numStyles - 1) * sizeof(Str255)));
  1219.             
  1220.             anErr = MemError();
  1221.             require(anErr == noErr, StyleTableResizeFailed);
  1222.             
  1223.             // Now extract the name of each of the supported fonts
  1224.             
  1225.             for (i = 1, pStyleName = ((char *) *theStyles) + sizeof(short); i <= numStyles; ++i, pStyleName += *pStyleName + 1)
  1226.             {
  1227.                 BlockMove(pStyleName, (*((gxStyleNameTableHdl) *(Handle *)dstData))->styleNames[i - 1], *pStyleName + 1);
  1228.             }
  1229.             
  1230.             (*((gxStyleNameTableHdl) *(Handle *)dstData))->numStyleNames = numStyles;
  1231.             
  1232.             // Dump the temporary handle
  1233.             DisposHandle(theStyles);
  1234.             
  1235.             break;
  1236.         }
  1237.             
  1238.         case gxGetJobFormatLineConstraintQuery:            //    This type of query is not supported
  1239.             if (*(Handle *)dstData != nil)
  1240.                 SetHandleSize(*(Handle *)dstData, 0);        // Don't return any data
  1241.             break;
  1242.             
  1243.         case gxGetJobFormatFontsQuery:
  1244.         {
  1245.             short                numFonts;
  1246.             short                i;
  1247.             char                *pFontName;
  1248.  
  1249.             // Fetch the list of supported fonts
  1250.             
  1251.             anErr = Send_GXFetchTaggedDriverData('STR#', kFormatModeFontsID, &theFonts);
  1252.             require(anErr == noErr, FailedToLoadFonts);
  1253.             
  1254.             HNoPurge(theFonts);
  1255.             HLock(theFonts);
  1256.             
  1257.             // Determine the number of fonts in the list
  1258.             numFonts = **((short **) theFonts);
  1259.  
  1260.             if (*(Handle *)dstData != nil)    //    T => Resize the handle to hold info. on the fonts
  1261.                 SetHandleSize(*(Handle *)dstData, sizeof(gxFontTable) + ((numFonts - 1) * sizeof(gxFont)));
  1262.             else
  1263.                 *(Handle *)dstData = NewHandle(sizeof(gxFontTable) + ((numFonts - 1) * sizeof(gxFont)));
  1264.             
  1265.             anErr = MemError();
  1266.             require(anErr == noErr, FontTableResizeFailed);
  1267.             
  1268.             // Now generate a reference to each of the supported fonts
  1269.             
  1270.             for (i = 1, pFontName = ((char *) *theFonts) + sizeof(short); i <= numFonts; ++i, pFontName += *pFontName + 1)
  1271.             {
  1272.                 gxFont            thisFont;
  1273.                 gxFontTable    *pFontTable;
  1274.             
  1275.                 thisFont = FindPNameFont(gxFullFontName, (unsigned char const *) pFontName);
  1276.                 
  1277.                 pFontTable = *((gxFontTableHdl) *(Handle *)dstData);
  1278.                 pFontTable->fonts[i - 1] = thisFont;
  1279.             }
  1280.             
  1281.             (*((gxFontTableHdl) *(Handle *)dstData))->numFonts = numFonts;
  1282.             
  1283.             // Dump the temporary handle
  1284.             DisposHandle(theFonts);
  1285.  
  1286.             break;
  1287.         }
  1288.             
  1289.         case gxGetJobFormatFontConstraintQuery:
  1290.         {
  1291.             gxPositionConstraintTable        *pPositionTable;
  1292.             
  1293.             if ( *(Handle *)dstData != nil)    //    T => Resize the handle to hold info. on position constraints
  1294.                 SetHandleSize(*(Handle *)dstData, sizeof(gxPositionConstraintTable) + sizeof(Fixed));
  1295.             else
  1296.                 *(Handle *)dstData = NewHandle( sizeof(gxPositionConstraintTable) + sizeof(Fixed) );
  1297.             
  1298.             pPositionTable = *((gxPositionConstraintTableHdl) *(Handle *)dstData);
  1299.             
  1300.             pPositionTable->phase.x     = 0;                //    Start at the top left corner of the page
  1301.             pPositionTable->phase.y     = 0;
  1302.             pPositionTable->offset.x     = ff(12);        // Indent from the top left by a six lines per inch margin
  1303.             pPositionTable->offset.y     = ff(12);         
  1304.             pPositionTable->numSizes     = 2;                // Two font sizes supported
  1305.             pPositionTable->sizes[0]     = ff(10);         // 10 pitch
  1306.             pPositionTable->sizes[1]     = ff(12);         // 12 pitch
  1307.             
  1308.             break;
  1309.         }
  1310.     } // switch
  1311.     
  1312.     return(anErr);
  1313.     
  1314.  
  1315. /******* Clean-up *******/
  1316.  
  1317. StyleTableResizeFailed:
  1318.     DisposHandle((Handle) theStyles);
  1319.     return(anErr);
  1320.  
  1321. FontTableResizeFailed:
  1322.     DisposHandle((Handle) theFonts);
  1323.  
  1324. FailedToLoadStyles1:
  1325. FailedToLoadStyles2:
  1326. FailedToLoadFonts:
  1327.     return(anErr);
  1328. }
  1329. /* SD_JobFormatModeQuery */
  1330.  
  1331.  
  1332. /****************************************************************************************
  1333.  
  1334.                             SD_OpenConnection
  1335.                             
  1336.     function:
  1337.                 This routine is called when the Printing Manager sends the OpenConnection
  1338.                 message.  We take this opportunity to open a connection to the printer and
  1339.                 query the printer to determine its configuration (e.g. color ribbon, trays, etc.).
  1340.                 We then save the configuration information in the desktop printer file.
  1341.                 
  1342.     parameters:        
  1343.                 None
  1344.                 
  1345.     returns:
  1346.                 OSErr
  1347.     
  1348. ****************************************************************************************/
  1349. OSErr SD_OpenConnection(void)
  1350. {
  1351.     OSErr                anErr;
  1352.  
  1353.     // Try to open the connection
  1354.     
  1355.     anErr = Forward_GXOpenConnection();
  1356.     require(anErr == noErr, Forward_GXOpenConnection);
  1357.     
  1358.     // Query the printer so we can update the configuration information
  1359.     
  1360.     anErr = UpdateDTPConfigInfo();
  1361.     require(anErr == noErr, UpdateDTPConfigInfo);
  1362.     
  1363.     return(anErr);
  1364.     
  1365.     
  1366. /******* Clean-up *******/
  1367.  
  1368. UpdateDTPConfigInfo:
  1369.     Send_GXCleanupOpenConnection();
  1370.     
  1371. Forward_GXOpenConnection:
  1372.     return(anErr);
  1373. }
  1374. /* SD_OpenConnection */
  1375.  
  1376.  
  1377. /****************************************************************************************
  1378.  
  1379.                             SD_CleanupOpenConnection
  1380.                             
  1381.     function:
  1382.                 This routine is called when the Printing Manager sends the CleanupOpenConnection
  1383.                 message.  It's initiated by our SD_OpenConnection routine when we cannot query
  1384.                 the printer after opening the connection.  We simply forward the message along to
  1385.                 allow others in the message chain to cleanup.
  1386.                 
  1387.     parameters:        
  1388.                 None
  1389.                 
  1390.     returns:
  1391.                 OSErr
  1392.     
  1393. ****************************************************************************************/
  1394. void SD_CleanupOpenConnection(void)
  1395. {
  1396.     // Just forward along the message
  1397.     Forward_GXCleanupOpenConnection();
  1398. }
  1399. /* SD_CleanupOpenConnection */
  1400.  
  1401.  
  1402. /****************************************************************************************
  1403.  
  1404.                             SD_StartSendPage
  1405.                             
  1406.     function:
  1407.                 This routine is called by the Printing Manager to signal the start of sending
  1408.                 a new page to the printer.  If it's a manual feed job, then we alert the user
  1409.                 to make sure the paper is in the printer.  If the printer has trays attached,
  1410.                 then this routine determines from which tray to feed the paper and then sends
  1411.                 the appropriate tray selection command to the printer.  The tray to pull the
  1412.                 paper from has already been determined by this time by the Universal Driver.
  1413.                 The Job collection contains the index of the tray to pull from.
  1414.                 
  1415.     parameters:                
  1416.                 pageFormat        format for the page to print
  1417.  
  1418.     returns:
  1419.                 OSErr
  1420.     
  1421. ****************************************************************************************/
  1422. OSErr SD_StartSendPage (gxFormat pageFormat)
  1423. {
  1424.     OSErr                    anErr;
  1425.     Collection            jobCollection;
  1426.     gxStatusRecord        *pStatus;
  1427.     gxTrayFeedInfo        trayFeedInfo;
  1428.     long                    itemSize = sizeof(trayFeedInfo);
  1429.     SpecGlobalsHdl     hGlobals = GetMessageHandlerInstanceContext();
  1430.     
  1431.     // Get a reference to the job's collection
  1432.     jobCollection = GXGetJobCollection( GXGetJob() );
  1433.     
  1434.     // Determine if this is a manual feed page 
  1435.  
  1436.     anErr = GetCollectionItem(jobCollection, gxTrayFeedTag, gxPrintingTagID, &itemSize, &trayFeedInfo);
  1437.     nrequire(anErr, GetCollectionItem);
  1438.     
  1439.     if (trayFeedInfo.manualFeedThisPage)    //    T => Alert the user to place the paper into the printer
  1440.     {
  1441.         gxManualFeedRecord    *mfeedInfo;
  1442.         gxPaperType                thePaperType;
  1443.  
  1444.         // Wait for all IO to complete, so that we can correctly tell the user what to do.
  1445.         // Since the WriteData message makes sure all data is flushed before performing the
  1446.         // IO, this call insures that pending IO is complete.
  1447.  
  1448.         anErr = Send_GXWriteData(nil, 0);
  1449.         nrequire(anErr, FlushAllData);
  1450.  
  1451.         // Now we set-up to alert the user to put paper into the printer
  1452.     
  1453.         pStatus = (gxStatusRecord *) NewPtrClear(sizeof(gxStatusRecord) + sizeof(gxManualFeedRecord));
  1454.         anErr = MemError();
  1455.         require(anErr == noErr, NewPtrClear);
  1456.     
  1457.         // Initialize the appropriate fields within the status record 
  1458.         
  1459.         pStatus->statusOwner        = 'univ';
  1460.         pStatus->statResId         = gxUnivAlertStatusResourceId;
  1461.         pStatus->statResIndex     = gxUnivManualFeedIndex;
  1462.         pStatus->bufferLen         = sizeof(gxManualFeedRecord);
  1463.  
  1464.         mfeedInfo = (gxManualFeedRecord *) &pStatus->statusBuffer;
  1465.         mfeedInfo->canAutoFeed = true;
  1466.         GXGetPaperTypeName(thePaperType = GXGetFormatPaperType(pageFormat), mfeedInfo->paperTypeName);
  1467.  
  1468.         // Now display the alert to the user. Continue alerting until the user clicks OK, he cancels
  1469.         // printing, or some other fatal error happens
  1470.         do
  1471.         {
  1472.             // Issue the alert to the user
  1473.             anErr = GXAlertTheUser(pStatus);
  1474.         }
  1475.         while ( (anErr == noErr) && (pStatus->dialogResult == 0) );
  1476.         
  1477.         // Based upon the users response, we continue, cancel, or switch to auto-feed
  1478.         
  1479.         switch (pStatus->dialogResult)
  1480.         {
  1481.             case ok:                        // Assume the user loaded the paper 
  1482.                 break;
  1483.                 
  1484.             case cancel:                // User cancelled the job; make sure the error code is set
  1485.                 anErr = gxPrUserAbortErr;
  1486.                 break;
  1487.                 
  1488.             case gxAutoFeedButtonId:    // User wishes to do the remainder of the job with auto-feed. Update job to 
  1489.                                             // reflect auto-feed. 
  1490.                 
  1491.                 {
  1492.                 gxPaperFeedInfo paperFeed;
  1493.                 
  1494.                 /* Update for job */
  1495.                 paperFeed.autoFeed = true;
  1496.                 (void) AddCollectionItem(jobCollection, gxPaperFeedTag, gxPrintingTagID, sizeof(paperFeed), &paperFeed);
  1497.                 }
  1498.                 
  1499.                 /* Update as it may be reused */
  1500.                 trayFeedInfo.manualFeedThisPage = false;    /* Other trayInfo fields are still valid */
  1501.                 (void) AddCollectionItem(jobCollection, gxTrayFeedTag, gxPrintingTagID, sizeof(trayFeedInfo), &trayFeedInfo);
  1502.                 
  1503.                 /* Can pass paper type reference as this IS device communication time */
  1504.                 anErr = Send_GXCheckStatus((Ptr) &thePaperType, sizeof(thePaperType), 0, 'univ');
  1505.                 ncheck(anErr);
  1506.                 
  1507.                 /* Update gxTrayFeedInfo.feedTrayIndex for below */
  1508.                 itemSize = sizeof(trayFeedInfo);
  1509.                 if (! anErr)
  1510.                     anErr = GetCollectionItem(jobCollection, gxTrayFeedTag, gxPrintingTagID, &itemSize, &trayFeedInfo);
  1511.                 break;
  1512.         }
  1513.         
  1514.         // Dump the status record
  1515.         DisposPtr((Ptr) pStatus);
  1516.     }
  1517.     
  1518.     require(anErr == noErr, UserAborted);
  1519.     
  1520.     // At this point we determine if there are trays attached, and if so, we need
  1521.     // to issue a command to the printer to select from the proper tray.
  1522.     
  1523.     if ( PrinterHasTrays() > 0 )    //    T => Printer does have trays attached
  1524.     {
  1525.         gxTrayIndex                whichTray;
  1526.         char                        cmndBuff[3];
  1527.         TraySettingsJobItem    oldAppTraySettings;
  1528.         
  1529.         // We first determine if we're printing from an old application or a new application because
  1530.         // the setting of which tray to use will be determined from different information. To see if
  1531.         // we are printing an old app. document, we look for the kTraySettingsItemIndex collection item.
  1532.         
  1533.         itemSize = sizeof(TraySettingsJobItem);
  1534.         if ( GetCollectionItem( GXGetJobCollection(GXGetJob()), kDrvrCreatorType, kTraySettingsItemIndex, &itemSize, &oldAppTraySettings) == noErr )
  1535.         {
  1536.             if ( (*hGlobals)->pagePrinting == 1 )    //    T => Printing the first page
  1537.             {
  1538.                 whichTray = oldAppTraySettings.firstPageFromTray - 1;        //    Must be zero based
  1539.             }
  1540.             else    //    T => Printing some other page
  1541.             {
  1542.                 whichTray = oldAppTraySettings.remainingFromTray - 1;        //    Must be zero based
  1543.             }
  1544.         }
  1545.         else    //    T => New app so get tray settings from the 'tray' collection item
  1546.         {
  1547.             // The trayFeedInfo specifies which tray to select the paper from.
  1548.             whichTray = trayFeedInfo.feedTrayIndex - 1;        // Must be zero based
  1549.         }
  1550.         
  1551.         // Compose the tray selection command
  1552.         
  1553.         cmndBuff[0] = kEscape;
  1554.         cmndBuff[1] = '@';
  1555.         cmndBuff[2] = whichTray + 0x30;        // Force to an ACSII number
  1556.         
  1557.         // Send the command to the printer
  1558.         anErr = Send_GXBufferData(cmndBuff, 3, gxNoBufferOptions);
  1559.         require(anErr == noErr, BufferData);        
  1560.     }
  1561.     
  1562.     // Update the status information to tell the user that we're sending data to the printer
  1563.     
  1564.     anErr = GXReportStatus(kDriverStatusID, kSendingPartOfPageStatIdx);
  1565.     require(anErr == noErr, ReportStatus);
  1566.  
  1567.     // Now forward the message to others in the chain
  1568.     
  1569.     anErr = Forward_GXStartSendPage(pageFormat);
  1570.     check(anErr == noErr);
  1571.     
  1572.     
  1573. /******* Cleanup *******/
  1574.  
  1575. ReportStatus:
  1576. BufferData:
  1577. UserAborted:
  1578. NewPtrClear:
  1579. FlushAllData:
  1580. GetCollectionItem:
  1581.     return(anErr);
  1582. }
  1583. /* SD_StartSendPage */
  1584.  
  1585.  
  1586. /****************************************************************************************
  1587.  
  1588.                             SD_ImagePage
  1589.                             
  1590.     function:
  1591.                 This routine is called by the Printing Manager to signal the start of imaging
  1592.                 a new page to the printer.  We take this opportunity to remember which page is
  1593.                 being printed.  This inforamtion is later used by SD_StartSendPage to control
  1594.                 the input tray selection for documents which are printed from old applications.
  1595.                 
  1596.     parameters:                
  1597.                 theFormat        format for the page being rendered
  1598.                 theShape            shape representing the page
  1599.                 pageInfo            information about the page being rendered
  1600.                 imageData        pointer to the raster image data
  1601.  
  1602.     returns:
  1603.                 OSErr
  1604.     
  1605. ****************************************************************************************/
  1606. OSErr SD_ImagePage (    gxSpoolFile                theFile, 
  1607.                             long                         pageNumber, 
  1608.                             gxFormat                    theFormat, 
  1609.                             gxRasterImageDataHdl    imageData)
  1610. {
  1611.     OSErr                    anErr;
  1612.     SpecGlobalsHdl     hGlobals = GetMessageHandlerInstanceContext();
  1613.  
  1614.     // Remember which page of the document we're currently imaging
  1615.     (*hGlobals)->pagePrinting = pageNumber;
  1616.     
  1617.     // Send the message along to others in the chain
  1618.     anErr = Forward_GXImagePage(theFile, pageNumber, theFormat, imageData);
  1619.     check(anErr == noErr);
  1620.     
  1621.     return(anErr);
  1622. }
  1623. /* SD_ImagePage */
  1624.  
  1625.  
  1626. /****************************************************************************************
  1627.  
  1628.                             SD_RenderPage
  1629.                             
  1630.     function:
  1631.                 This routine is called by the Printing Manager to signal the start of sending
  1632.                 a new page to the printer.  If it's a manual feed job, then we alert the user
  1633.                 to make sure the paper is in the printer.  Next we set the printer's left margin
  1634.                 and then we're set to begin printing the page.
  1635.                 
  1636.     parameters:                
  1637.                 theFormat        format for the page being rendered
  1638.                 theShape            shape representing the page
  1639.                 pageInfo            information about the page being rendered
  1640.                 imageData        pointer to the raster image data
  1641.  
  1642.     returns:
  1643.                 OSErr
  1644.     
  1645. ****************************************************************************************/
  1646. OSErr SD_RenderPage (gxFormat                        theFormat, 
  1647.                             gxShape                        thePage, 
  1648.                             gxPageInfoRecord            *pageInfo, 
  1649.                             gxRasterImageDataHdl     imageData)
  1650. {
  1651.     OSErr                    anErr;
  1652.     SpecGlobalsHdl     hGlobals = GetMessageHandlerInstanceContext();
  1653.     gxRectangle            paperSize;
  1654.     
  1655.     // Find out how big our paper is
  1656.     GXGetFormatDimensions(theFormat, nil, &paperSize);
  1657.     
  1658.     // Determine the left margin (in pixels)
  1659.     {
  1660.         SpecGlobalsPtr            pGlobals;
  1661.         gxRasterImageDataPtr    pImageData;
  1662.  
  1663.         pImageData = *imageData;
  1664.         pGlobals = *hGlobals;
  1665.         if ( -(paperSize.left) < ff(18) )    // T => IW LQ's can't go tighter than .25 inch
  1666.             paperSize.left = -(ff(18));        
  1667.         
  1668.         pGlobals->leftMargin = FixedToInt( FixMul(-paperSize.left, FixDiv(pImageData->hImageRes, ff(72)) ) );
  1669.     }
  1670.  
  1671.     // If not text mode, image the page the normal raster way (via SD_RasterPackageBitmap).  We
  1672.     // must however set the size of the page and position the paper (with line feeds) to get to
  1673.     // the proper "top-of-form".
  1674.     
  1675.     if ( GXGetJobFormatMode(GXGetJob()) != gxTextJobFormatMode ) 
  1676.     {
  1677.         Str255            formStrLength;            // should be more than big enough for form skipping
  1678.         char                aNumber[8];
  1679.         char                len = 0;
  1680.         short                formLen;                // form length (in 144 dpi)
  1681.         short                i;
  1682.         
  1683.         // Force the current line position to be the top of form (assumes the user has positioned the 
  1684.         // paper properly by this time)
  1685.         
  1686.         formStrLength[len++] = kEscape;
  1687.         formStrLength[len++] = 'v';
  1688.  
  1689.         // Now we want to skip down the page past the top margin.  This will put us in a position to
  1690.         // output the first bands of data.
  1691.         
  1692.         formLen = FixedToInt( FixMul(-paperSize.top, ff(2)) );                    // length is set in 144 dpi
  1693.         if (formLen > 0)
  1694.         {
  1695.             // send multiples of 99 since this is the maximum line feed spacing we can have
  1696.             if (formLen >= 99)
  1697.             {
  1698.                 formStrLength[len++] = kEscape;
  1699.                 formStrLength[len++] = 'T';
  1700.                 formStrLength[len++] = '9';
  1701.                 formStrLength[len++] = '9';
  1702.                 do
  1703.                 {
  1704.                     formStrLength[len++] = kLineFeed;        // line feed
  1705.                     
  1706.                     formLen -= 99;
  1707.                 }
  1708.                 while (formLen >= 99);
  1709.             }
  1710.                 
  1711.             // Send remaining line feeds to position to the top of the printable page
  1712.             if (formLen > 0)
  1713.             {
  1714.                 formStrLength[len++] = kEscape;
  1715.                 formStrLength[len++] = 'T';
  1716.                 NumToString(formLen, (unsigned char *) aNumber);
  1717.                 if ( StrLength(aNumber) == 1 )
  1718.                 {
  1719.                     formStrLength[len++] = '0';
  1720.                     formStrLength[len++] = aNumber[1];
  1721.                 }
  1722.                 else
  1723.                 {
  1724.                     formStrLength[len++] = aNumber[1];
  1725.                     formStrLength[len++] = aNumber[2];
  1726.                 }
  1727.                 formStrLength[len++] = kLineFeed;        // line feed
  1728.             }
  1729.         }
  1730.         
  1731.         // Now we must specify the paper length based upon the paper size asociated with the format
  1732.         
  1733.         formStrLength[len++] = kEscape;
  1734.         formStrLength[len++] = 'H';
  1735.  
  1736.         formLen = FixedToInt( FixMul(paperSize.bottom - paperSize.top, ff(2)) );    // length is set in 144 dpi
  1737.         NumToString(formLen, (unsigned char *) aNumber);
  1738.         for (i = 0; i < 4-aNumber[0]; ++i)
  1739.             formStrLength[len++] = '0';
  1740.         for (i = 1; i <= aNumber[0]; ++i)
  1741.             formStrLength[len++] = aNumber[i];
  1742.  
  1743.         // Send out the line feeds and the paper size specifier
  1744.         anErr = Send_GXBufferData((char *) &formStrLength[0], len, gxNoBufferOptions);
  1745.         require(anErr == noErr, SetFormStrLength);        
  1746.     
  1747.         // Now forward the message to others in the chain
  1748.         
  1749.         anErr = Forward_GXRenderPage(theFormat, thePage, pageInfo, imageData);
  1750.         require(anErr == noErr, Forward_GXRenderPage);
  1751.     } 
  1752.     else    //    T => Doing draft (i.e. direct mode) print job; we do all the rendering
  1753.     {
  1754.         anErr = PrintPageInDraftMode(thePage, imageData);
  1755.     }
  1756.     
  1757.     
  1758. /******* Cleanup *******/
  1759.  
  1760. SetFormStrLength:
  1761. Forward_GXRenderPage:
  1762.     return(anErr);
  1763. }
  1764. /* SD_RenderPage */
  1765.  
  1766.  
  1767. /****************************************************************************************
  1768.  
  1769.                             SD_DefaultPrinter
  1770.                             
  1771.     function:
  1772.                 This routine is called when a new printer object is being created as a
  1773.                 result of someone having called NewJob.  This message gives the driver the
  1774.                 opportunity to add any information we want to the new printer object.  In
  1775.                 this case, we add a new black and white viewDevice to the printer object 
  1776.                 which will allow the client application to format a document for this 
  1777.                 specific device at 216 dpi.  If the printer has a color ribbon attachment,
  1778.                 then we create a second view device at 216 dpi which supports eight
  1779.                 colors.
  1780.                 
  1781.     parameters:                
  1782.                 thePrinter        the newly allocated printer object
  1783.                 
  1784.     returns:
  1785.                 OSErr
  1786.                 
  1787. ****************************************************************************************/
  1788. OSErr SD_DefaultPrinter(gxPrinter thePrinter)
  1789. {
  1790.     OSErr             anErr;
  1791.     gxSetColor        theColors[8];
  1792.     gxSetColor        *pColor;
  1793.     
  1794.     // First we let others in the chain default the printer object before we do. 
  1795.  
  1796.     anErr = Forward_GXDefaultPrinter(thePrinter);
  1797.     require(anErr == noErr, Forward_GXDefaultPrinter);
  1798.     
  1799.     // Add the standard black and white view device to the printer object
  1800.     
  1801.     // First set up the color set
  1802.     pColor = &theColors[0];
  1803.     pColor->rgb.red = pColor->rgb.green = pColor->rgb.blue = 0xFFFF;            // white 
  1804.     pColor++;
  1805.     pColor->rgb.red = pColor->rgb.green = pColor->rgb.blue = 0x0000;            // black 
  1806.     
  1807.     // Now add the view device
  1808.     anErr = MakeNewPrinterViewDevice(thePrinter, theColors, 2);
  1809.     require(anErr == noErr, MakeBWViewDevice);
  1810.     
  1811.     // Does the printer have a color ribbon installed?
  1812.     if ( PrinterHasColorRibbon() )
  1813.     {
  1814.         // Add the standard color view device to the printer object
  1815.         
  1816.         // First set up the color set
  1817.         //
  1818.         //    Color            Index        R                G                B
  1819.         //    white            0            0xFFFF        0xFFFF        0xFFFF        
  1820.         //    yellow        1            0xFFFF        0xFFFF        0x0000
  1821.         //    magenta        2            0xFFFF        0x0000        0xFFFF
  1822.         //    red            3            0xFFFF        0x0000        0x0000
  1823.         //    cyan            4            0x0000        0xFFFF        0xFFFF
  1824.         //    green            5            0x0000        0xFFFF        0x0000
  1825.         //    blue            6            0x0000        0x0000        0xFFFF
  1826.         //    black            7            0x0000        0x0000        0x0000
  1827.  
  1828.         pColor = &theColors[0];
  1829.         pColor->rgb.red = pColor->rgb.green = pColor->rgb.blue = 0xFFFF;                pColor++;        // white 
  1830.         pColor->rgb.red = pColor->rgb.green = 0xFFFF; pColor->rgb.blue = 0x0000;    pColor++;        // yellow 
  1831.         pColor->rgb.red = pColor->rgb.blue = 0xFFFF; pColor->rgb.green = 0x0000;    pColor++;        // magenta 
  1832.         pColor->rgb.red =0xFFFF;  pColor->rgb.blue = pColor->rgb.green = 0x0000;    pColor++;        // red 
  1833.         pColor->rgb.green = pColor->rgb.blue = 0xFFFF; pColor->rgb.red = 0x0000;    pColor++;        // cyan 
  1834.         pColor->rgb.red = pColor->rgb.blue = 0x0000; pColor->rgb.green = 0xFFFF;    pColor++;        // green 
  1835.         pColor->rgb.red = pColor->rgb.green = 0x0000; pColor->rgb.blue = 0xFFFF;    pColor++;        // blue 
  1836.         pColor->rgb.red = pColor->rgb.green = pColor->rgb.blue = 0x0000;                                    // black 
  1837.         
  1838.         // Now add the view device
  1839.         anErr = MakeNewPrinterViewDevice(thePrinter, theColors, 8);
  1840.         require(anErr == noErr, MakeColorViewDevice);
  1841.     }
  1842.     
  1843. /******* Clean-up *******/
  1844.  
  1845. MakeColorViewDevice:
  1846. MakeBWViewDevice:
  1847. Forward_GXDefaultPrinter:
  1848.     return(anErr);
  1849. }
  1850. /* SD_DefaultPrinter */
  1851.  
  1852. /****************************************************************************************
  1853.  
  1854.                             SD_DefaultFormat
  1855.                             
  1856.     function:
  1857.                 This routine is called when a new format is being created as a result of someone
  1858.                 having called NewFormat.  It is also called to sync up the viewDevices with the
  1859.                 collection's quality mode.
  1860.                 
  1861.     parameters:                
  1862.                 theFormat        the format being defaulted
  1863.                 
  1864.     returns:
  1865.                 OSErr
  1866.                 
  1867. ****************************************************************************************/
  1868. OSErr SD_DefaultFormat(gxFormat theFormat)
  1869. {
  1870.     OSErr                anErr;
  1871.     Handle             jobQualitySettingsHdl;    
  1872.     
  1873.     anErr = Forward_GXDefaultFormat(theFormat);
  1874.     
  1875.     // now, if the application has set up a special formatting mode, we need to update
  1876.     // the quality mode collection item (and any private ones we use)
  1877.     if (anErr == noErr)
  1878.         {
  1879.         gxPoint                    dpiPoint;
  1880.         gxMapping                vdMapping;
  1881.         gxViewDevice            selectedDevice = GXGetPrinterViewDevice(GXGetJobPrinter(GXGetFormatJob(theFormat)), 0);
  1882.         
  1883.         dpiPoint.x = ff(72);
  1884.         dpiPoint.y = ff(72);
  1885.         
  1886.         if (selectedDevice != GXGetPrinterViewDevice(GXGetJobPrinter(GXGetFormatJob(theFormat)), 1) )
  1887.             {
  1888.             GXGetViewDeviceMapping(selectedDevice, &vdMapping);
  1889.             MapPoints(&vdMapping, 1, &dpiPoint);
  1890.             
  1891.             {
  1892.             gxQualityInfo        *qualitySettings;
  1893.             Collection            jobCollection = GXGetJobCollection(GXGetJob());
  1894.     
  1895.             jobQualitySettingsHdl = NewHandle(0);
  1896.             anErr = MemError();
  1897.             nrequire(anErr, FailedNewHandle);
  1898.  
  1899.             anErr = GetCollectionItemHdl (     jobCollection,
  1900.                                                         gxQualityTag,
  1901.                                                          gxPrintingTagID,
  1902.                                                        jobQualitySettingsHdl );
  1903.  
  1904.             if (anErr == collectionItemNotFoundErr) 
  1905.                 {
  1906.                 Str255            bestString, roughString;
  1907.                 Size                count1, count2;
  1908.                 Ptr                p;
  1909.         
  1910.                 GetIndString( bestString, kQualityID, kBestString);
  1911.                 GetIndString( roughString, kQualityID, kRoughString);
  1912.  
  1913.                 SetHandleSize(jobQualitySettingsHdl,(sizeof(gxQualityInfo) + bestString[0] + roughString[0] + 2 ));
  1914.                 anErr = MemError();
  1915.                 nrequire( anErr, FailedSetHandleSize );
  1916.                         
  1917.                 qualitySettings = *((gxQualityInfo **) jobQualitySettingsHdl);
  1918.                 
  1919.                 qualitySettings->disableQuality = false;
  1920.                 qualitySettings->defaultQuality = 1;
  1921.                 qualitySettings->currentQuality = 1;
  1922.                 qualitySettings->qualityCount = 2;
  1923.         
  1924.                 count1 = bestString[0]+1;
  1925.                 p = qualitySettings->qualityNames;
  1926.                 BlockMove( bestString, p, count1 );
  1927.         
  1928.                 count2 = roughString[0]+1;
  1929.                 p += count1;
  1930.                 BlockMove( roughString, p, count2 );
  1931.         
  1932.                 }
  1933.             else
  1934.                 qualitySettings = *((gxQualityInfo **) jobQualitySettingsHdl);
  1935.  
  1936.             qualitySettings->currentQuality = 
  1937.                 (dpiPoint.y > ff(200)) ? (qualitySettings->qualityCount-1) : 0;
  1938.  
  1939.             anErr = AddCollectionItemHdl (     jobCollection,
  1940.                                                         gxQualityTag,
  1941.                                                         gxPrintingTagID,
  1942.                                                         jobQualitySettingsHdl );
  1943.                                                  
  1944.             if (anErr == noErr)
  1945.                 (void) SetCollectionItemInfo(jobCollection, gxQualityTag, gxPrintingTagID, 0x0000FFFF, gxVolatileOutputDriverCategory);
  1946.                 
  1947.             DisposHandle(jobQualitySettingsHdl);
  1948.             }
  1949.             
  1950.             }
  1951.  
  1952.         }
  1953.         
  1954. FailedNewHandle:        
  1955.     return(anErr);
  1956.  
  1957. FailedSetHandleSize:
  1958.     DisposHandle(jobQualitySettingsHdl);
  1959.     return(anErr);
  1960.     
  1961. } 
  1962. /* SD_DefaultFormat */
  1963.  
  1964. /****************************************************************************************
  1965.  
  1966.                             SD_DefaultJob
  1967.                             
  1968.     function:
  1969.                 This routine is called when a new job is being created as a result of someone
  1970.                 having called NewJob.  The driver takes this opportunity to add a default
  1971.                 head motion collection item to the job.
  1972.                 
  1973.     parameters:                
  1974.                 theJob        the job being defaulted
  1975.                 
  1976.     returns:
  1977.                 OSErr
  1978.                 
  1979. ****************************************************************************************/
  1980. OSErr SD_DefaultJob()
  1981. {
  1982.     OSErr        anErr;
  1983.     gxJob     theJob = GXGetJob();
  1984.     
  1985.     // First forward the default job message along
  1986.     anErr = Forward_GXDefaultJob();
  1987.     require(anErr == noErr, Forward_GXDefaultJob);
  1988.     
  1989.     // Add the default collection item which specifies the desired head motion.
  1990.     {
  1991.         HeadMotionJobItem        theMotion;
  1992.         
  1993.         theMotion.direction = doUnidirectional;
  1994.         
  1995.         anErr = AddCollectionItem(    GXGetJobCollection(theJob), 
  1996.                                             kDrvrCreatorType, 
  1997.                                             kHeadMotionItemIndex, 
  1998.                                             sizeof(HeadMotionJobItem),
  1999.                                             &theMotion);
  2000.         check(anErr == noErr);
  2001.     }
  2002.  
  2003.  
  2004. /******* Clean-up *******/
  2005.  
  2006. Forward_GXDefaultJob:
  2007.     return(anErr);
  2008. }
  2009. /* SD_DefaultJob */
  2010.  
  2011.  
  2012. /****************************************************************************************
  2013.  
  2014.                             SD_SetupImageData
  2015.                             
  2016.     function:
  2017.                 This routine is called when the Printing Manager wants us to initialize any
  2018.                 constant data that's used to image the entire job.  This driver takes this
  2019.                 opportunity to massage the raster image data 
  2020.                 
  2021.     parameters:                
  2022.                 hImageData        Handle to the raster imaging data
  2023.     returns:
  2024.                 OSErr
  2025.     
  2026. ****************************************************************************************/
  2027. OSErr SD_SetupImageData(gxRasterImageDataHdl hImageData)
  2028. {
  2029.     OSErr                        anErr;
  2030.     Boolean                     isJobNotFinalQuality;
  2031.     Boolean                    isTextJobFormatMode;
  2032.     gxRasterImageDataPtr    pImageData;
  2033.     HeadMotionJobItem        theMotion;
  2034.     long                        headMotionSize;
  2035.     gxJob                        theJob = GXGetJob();
  2036.  
  2037.     // Let others in the message chain do their SetupImageData function 
  2038.     anErr = Forward_GXSetupImageData(hImageData);
  2039.     require(anErr == noErr, Forward_GXSetupImageData);
  2040.     
  2041.     // Determine if we're to do "final" quality
  2042.     isJobNotFinalQuality = !JobIsBestQuality();
  2043.     
  2044.     // Fetch the head motion job collection item to determine the head motion we should be using
  2045.  
  2046.     headMotionSize = sizeof(HeadMotionJobItem);
  2047.     anErr = GetCollectionItem (GXGetJobCollection(theJob),
  2048.                                         kDrvrCreatorType,
  2049.                                         kHeadMotionItemIndex,
  2050.                                         &headMotionSize,
  2051.                                         &theMotion);
  2052.     check(anErr == noErr);
  2053.     
  2054.     if (anErr != noErr)    //    T => Default to unidirectional printing => better quality
  2055.     {
  2056.         theMotion.direction = doUnidirectional;
  2057.         anErr = noErr;
  2058.     }
  2059.  
  2060.     // Determine if we are to perform draft mode printing
  2061.     isTextJobFormatMode = ( GXGetJobFormatMode(theJob) == gxTextJobFormatMode );
  2062.     
  2063.     // If the job is not final quality or using textJobFormatMode, downgrade the imaging data to lower quality
  2064.     if (isJobNotFinalQuality || isTextJobFormatMode)
  2065.     {
  2066.         pImageData = *hImageData;
  2067.                 
  2068.         // Image at 72 dpi
  2069.         pImageData->hImageRes = ff(72);
  2070.         pImageData->vImageRes = ff(72);
  2071.         
  2072.         // If we're in draft mode, we need to load the draft table to know how to print all possible characters
  2073.         if (isTextJobFormatMode)
  2074.         {
  2075.             Handle                draftTable;
  2076.             SpecGlobalsHdl     hGlobals = GetMessageHandlerInstanceContext();
  2077.         
  2078.             anErr = Send_GXFetchTaggedDriverData('idft', gxPrintingDriverBaseID, &draftTable);
  2079.             require(anErr == noErr, FailedToLoadDraftTable);
  2080.             
  2081.             // Save the draft table handle in our globals
  2082.             (*hGlobals)->draftTable = draftTable;
  2083.         }
  2084.         else    //    T => We need to setup better low resolution halftones
  2085.         {
  2086.             short    plane;
  2087.             
  2088.             // Use halftones that will look better at 72 dpi resolution than our default values.
  2089.             
  2090.             // Use the same angle and frequency for all planes, because orderDitherDot
  2091.             // won't moire on us
  2092.             for (plane = 0; plane < 4; ++plane)
  2093.             {
  2094.                 pImageData->theSetup.planeSetup[plane].planeHalftone.angle = ff(0);
  2095.                 pImageData->theSetup.planeSetup[plane].planeHalftone.frequency = ff(9);
  2096.                 pImageData->theSetup.planeSetup[plane].planeHalftone.method = gxDispersedDot;
  2097.             }
  2098.         }
  2099.         
  2100.         // Determine the StartSendPage command string to use depending upon whether the user choose birdirectional or
  2101.         // unidirectional motion.
  2102.         
  2103.         if (isJobNotFinalQuality)
  2104.         {
  2105.             // Tell the Printing Manager which "start send page" string to send to the device (the bidirectional
  2106.             // or unidirectional string)
  2107.             
  2108.             if ( theMotion.direction == doUnidirectional )
  2109.                 pImageData->packageControls.startPageStringID = kLowResUniDirID;
  2110.             else
  2111.                 pImageData->packageControls.startPageStringID = kLowResBiDirID;
  2112.         }
  2113.         
  2114.         // Update the packaging data to reflect the lower resolution
  2115.         pImageData->packagingInfo.headHeight         = 8;        // 8 pins (instead of 24)
  2116.         pImageData->packagingInfo.numberPasses     = 1;        // in 1 head pass
  2117.         pImageData->packagingInfo.passOffset         = 0;        // with no space between passes
  2118.     }
  2119.     else    //    T => Final quality job
  2120.     {
  2121.         pImageData = *hImageData;
  2122.                 
  2123.         // Tell the Printing Manager which "start send page" string to send to the device (the bidirectional
  2124.         // or unidirectional string)
  2125.         
  2126.         if ( theMotion.direction == doUnidirectional )
  2127.             pImageData->packageControls.startPageStringID = kHighResUniDirID;
  2128.         else
  2129.             pImageData->packageControls.startPageStringID = kHighResBiDirID;
  2130.  
  2131.         // image at 216 dpi
  2132.         pImageData->hImageRes = ff(216);
  2133.         pImageData->vImageRes = ff(216);
  2134.     }
  2135.     
  2136.     // If the printer doesn't have a color ribbon, set up for black and white printing
  2137.     if ( !PrinterHasColorRibbon() )
  2138.     {
  2139.         pImageData = *hImageData;
  2140.  
  2141.         // one plane, no color flags, move the halftone info up into correct position
  2142.         pImageData->theSetup.planes = 1;
  2143.         pImageData->packagingInfo.colorPasses = 1;
  2144.         pImageData->packagingInfo.packageOptions = 0;
  2145.         pImageData->theSetup.planeSetup[0] = pImageData->theSetup.planeSetup[3];
  2146.         pImageData->theSetup.planeSetup[0].planeHalftone.tinting = gxLuminanceTint;
  2147.         pImageData->theSetup.planeSetup[0].planeHalftone.tintSpace = gxRGBSpace;
  2148.     }
  2149.  
  2150.  
  2151. /******* Clean-up *******/
  2152.  
  2153. FailedToLoadDraftTable:
  2154. Forward_GXSetupImageData:
  2155.     return(anErr);
  2156. }
  2157. /* SD_SetupImageData */
  2158.  
  2159.  
  2160. /****************************************************************************************
  2161.  
  2162.                             SD_FetchTaggedData
  2163.                             
  2164.     function:
  2165.                 This routine is called by the Printing Manager when a resource is fetched
  2166.                 from some resource file.  This driver overrides this message to determine
  2167.                 when someone is fetching the 'cust' resource.  If this resource
  2168.                 is being fetched, and the job we're processing is not best quality, then
  2169.                 we lower the resolution in the 'cust' resource handle returned to be 72 dpi.
  2170.                 This ensures the translation from QuickDraw to QuickDraw GX is done at the
  2171.                 proper resolution.
  2172.                 
  2173.     parameters:    
  2174.                 rsrcType            type of the resource being retrieved
  2175.                 rsrcID            resource ID of the resource being retrieved
  2176.                 theRsrc            handle to the resource retrieved
  2177.                 owner                indicates who is issuing the request; only look at owners == 'drvr'
  2178.                 
  2179.     returns:
  2180.                 OSErr
  2181.  
  2182. ****************************************************************************************/
  2183. OSErr SD_FetchTaggedData(ResType rsrcType, short rsrcID, Handle *theRsrc, OSType owner)
  2184. {
  2185.     OSErr        anErr;
  2186.     
  2187.     if (owner == 'drvr')                                                    //    T => Fetching a driver resource
  2188.     {
  2189.         if (    (rsrcType == gxTrayCountDataType)    &&                    //    T => type is trayCountData
  2190.                 (rsrcID == gxTrayCountDataID)                            //    T => ID is trayCountData
  2191.             )
  2192.         {
  2193.             // Remap as required
  2194.             rsrcID = ((PrinterHasTrays() > 0) ? kDefaultSheetFeederRsrcID : kDefaultTrayRsrcID);
  2195.         }
  2196.         else if (    (rsrcType == gxTrayNameDataType)    &&            //    T => type is trayName
  2197.                         (rsrcID == kDefaultSheetFdrTray1NameID)    //    T => ID is trayData
  2198.             )
  2199.         {
  2200.             // Remap as required
  2201.             rsrcID = ((PrinterHasTrays() > 0) ? kDefaultSheetFdrTray1NameID : kDefaultTrayNameID);
  2202.         }
  2203.     }
  2204.     
  2205.     // First fetch the actual resource
  2206.     anErr = Forward_GXFetchTaggedData(rsrcType, rsrcID, theRsrc, owner);
  2207.     require(anErr == noErr, FetchTaggedData);
  2208.     
  2209.     if (    (owner == 'drvr')                &&        //    T => Fetching a driver resource
  2210.             (rsrcType == gxCustType)    &&        //    T => type is 'cust'
  2211.             (rsrcID == gxCustID)            &&        //    T => ID is -8192
  2212.             !JobIsBestQuality()                    //    T => Doing rough output
  2213.         )
  2214.     {
  2215.         gxCustomizationHdl    custData;
  2216.         
  2217.         // Change the 'cust' resolution to specify low res translation from QuickDraw to QuickDraw GX
  2218.         (*custData)->horizontalResolution = 72;
  2219.         (*custData)->verticalResolution = 72;
  2220.     }
  2221.  
  2222.  
  2223. /******* Clean-up *******/
  2224.  
  2225. FetchTaggedData:
  2226.     return(anErr);
  2227. }
  2228. /* SD_FetchTaggedData */
  2229.  
  2230.  
  2231. /****************************************************************************************
  2232.  
  2233.                             SD_DefaultDesktopPrinter
  2234.                             
  2235.     function:
  2236.                 This routine is called by the Printing Manager when a new desktop printer is
  2237.                 created.  We take this opportunity to open a connection to the LQ printer to
  2238.                 see how it's configured.  Specifically, we determine if there are trays
  2239.                 attached and if there is a color ribbon installed.  Based upon the device query,
  2240.                 we update the desktop printer file.
  2241.                 
  2242.     parameters:    
  2243.                 printerName        Name of the printer being created
  2244.                 
  2245.     returns:
  2246.                 OSErr
  2247.  
  2248. ****************************************************************************************/
  2249. OSErr SD_DefaultDesktopPrinter(Str31 printerName)
  2250. {
  2251.     OSErr        anErr;
  2252.     
  2253.     // First let the Printing Manager create the desktop printer
  2254.     anErr = Forward_GXDefaultDesktopPrinter(printerName);
  2255.     require(anErr == noErr, DefaultDesktopPrinter);
  2256.     
  2257.     // Optional step (now removed): during creation of the printer we could open a connection
  2258.     // to get the current configuration.  However, this has the disadvantage of making the user
  2259.     // wait until the printer is available.  The user can force a configuration update by printing
  2260.     // any document to the printer (even a blank one)
  2261.     
  2262.     // Now we attempt to open a connection to the device (it will update the config. file)
  2263. //    anErr = Send_GXOpenConnection();
  2264. //    require(anErr == noErr, OpenConnection);
  2265.     
  2266.     // A side effect of opening the connection will be that we will have already updated
  2267.     // the configuration information (in the file) that specifies whether a color ribbon
  2268.     // is installed and the number of sheet feeder trays attached (if any). ## The only additional
  2269.     // thing we'd want to do here is to update the number of trays specified in the desktop
  2270.     // printer file to be the actual number of trays attached to the device.  Currently, the 
  2271.     // system assumes the number of trays attached is equivalent to the number of default
  2272.     // trays specified in our driver resources.  Though we can query the printer for the 
  2273.     // exact number of trays, we cannot update the info. in the config. file that specifies
  2274.     // the exact number of trays.  We need a RemoveTrayInfo routine.
  2275.     
  2276.     // Now we just close down the connection
  2277. //    anErr = Send_GXCloseConnection();
  2278. //    check(anErr == noErr);
  2279.  
  2280.     
  2281. /******* Clean-up *******/
  2282.  
  2283. OpenConnection:
  2284. DefaultDesktopPrinter:
  2285.     return(anErr);
  2286. }
  2287. /* SD_DefaultDesktopPrinter */
  2288.  
  2289.  
  2290. /****************************************************************************************
  2291.  
  2292.                             SD_GetDTPMenuList
  2293.                             
  2294.     function:
  2295.                 NOOP.
  2296.                 
  2297.     parameters:    
  2298.                 hMenu            Handle to the menu that's being built
  2299.                 
  2300.     returns:
  2301.                 OSErr
  2302.  
  2303. ****************************************************************************************/
  2304. OSErr SD_GetDTPMenuList(MenuHandle hMenu)
  2305. {
  2306.     return(Forward_GXGetDTPMenuList(hMenu));
  2307. }
  2308. /* SD_GetDTPMenuList */
  2309.  
  2310.  
  2311. /****************************************************************************************
  2312.  
  2313.                             SD_DTPMenuSelect
  2314.                             
  2315.     function:
  2316.                 This routine is called by the Printing Manager when a menu item in the Finder's
  2317.                 Printer menu is selected.  This routine determines if the menu item selected
  2318.                 is the "Input Tray…" item. If it's, then display the dialog which lets the user
  2319.                 specify the paper in the LQ's sheet feeder if we know there are some trays
  2320.                 attached to the printer.  Otherwise, we just pass the item on to others in the chain.
  2321.                 
  2322.     parameters:    
  2323.                 itemNum        Menu item number that was selected
  2324.                 
  2325.     returns:
  2326.                 OSErr
  2327.  
  2328. ****************************************************************************************/
  2329. OSErr SD_DTPMenuSelect(short itemNum)
  2330. {
  2331.     OSErr        anErr;
  2332.     
  2333.     if ((itemNum == gxInputTraysMenuItem) && (PrinterHasTrays() > 0))    //    T => User wants to configure the input trays
  2334.     {
  2335.         anErr = DoSheetfeederDialog();
  2336.         
  2337.     }
  2338.     else    //    T => We didn't process the item
  2339.     {
  2340.         // Pass the message on to others in the chain
  2341.         anErr = Forward_GXDTPMenuSelect(itemNum);
  2342.     }
  2343.     
  2344.     check(anErr == noErr);
  2345.  
  2346.     return(anErr);
  2347. }
  2348. /* SD_DTPMenuSelect */
  2349.  
  2350.  
  2351. /****************************************************************************************
  2352.  
  2353.                             SD_RasterPackageBitmap
  2354.                             
  2355.     function:
  2356.                 This routine is called by the Printing Manager when it has completed rendering
  2357.                 a single portion of a raster page and the driver should now package the data
  2358.                 and output it to the device.  This routine is called to package one complete band.
  2359.                 
  2360.                 It routine does the following:
  2361.                     
  2362.                 1)    Starts filling the buffer from buffer + bufferPos.  Remember
  2363.                     that this pointer may not be word aligned - so be careful
  2364.                     assigning things into it.
  2365.                     
  2366.                 2)    Puts a "fake" set of set margins commands at
  2367.                     the begining of the data.  Since most of the time we don't
  2368.                     know the margins, we save away the value of the bufferPos,
  2369.                     and backpatch it after we have finished with the bitmap.
  2370.                     
  2371.                 3)    Adds in the rotated data for your printer.  The data to stuff starts
  2372.                     at location pPackage->startRaster * pPackage->bitmapToPackage->rowBytes (startY)
  2373.                     in the pPackage->bitmapToPackage bitmap.  Stuffs the bits from here until
  2374.                     we reach startY + <the band size>, which is the size of our single
  2375.                     band in this resolution mode.  Increment our number by 
  2376.                     <your pass offset> + 1, which is the number of microspaces
  2377.                     we will send between head passes to form this band.   Take care
  2378.                     that we don't step off of the end of the bitmap in this operation,
  2379.                     since we may be called with startY at the end of the offscreen if the first part
  2380.                     of the band is white.
  2381.                     
  2382.                     colorBand contains the color band which we should be stuffing, from
  2383.                     1 to the number of color passes our printer needs (4).
  2384.                     Packs in the correct color band.  The packager will call us once
  2385.                     for each color band, and correctly handle line feeds and backward
  2386.                     line feeds to do the correct thing.  If your printer takes full
  2387.                     RGB or CYMK data, define your number of colors to be
  2388.                     1 and pack the full RGB or CYMK data with the one call.
  2389.                     
  2390.                     If you request kSendAllColors in your raster pack resource, then this
  2391.                     message will always be called for all color passes, even those that
  2392.                     do not have data on them.  For some printers, this is useful.  For the
  2393.                     case of the ImageWriter, this option is not specified, so this message
  2394.                     will only be sent for colors that actually have dirty bits within them.
  2395.                     
  2396.                 4)    Backpatches SetMargins from the saved value in step 2) now that we
  2397.                     know the margins.
  2398.                     
  2399.                 5)    Increments bufferPos by the number of bytes we have
  2400.                     added to the buffer.  Be sure to take into account the Set Margins
  2401.                     command.
  2402.  
  2403.     parameters:        
  2404.                 whatToPackage        info. about the bitmap whose data is to be sent to the printer
  2405.                 buffer                buffer in which to place the packaged data
  2406.                 bufferPos            position within buffer of where to place the packaged data
  2407.                 imageData            handle to the raster image data info.
  2408.                 
  2409.     returns:
  2410.                 OSErr
  2411.  
  2412. ****************************************************************************************/
  2413. OSErr SD_RasterPackageBitmap(    gxRasterPackageBitmapRec    *whatToPackage, 
  2414.                                         Ptr                                 buffer,
  2415.                                         unsigned long                     *bufferPos, 
  2416.                                         gxRasterImageDataHdl            imageData)
  2417. {
  2418.     OSErr                    anErr = noErr;
  2419.     ScanLinePtr            pTheScanLine;            // Pointer to the start of scan line data
  2420.     unsigned short        firstDirty;                // First dirty pixel
  2421.     Boolean                bandIsDirty;            // Is this band dirty?
  2422.     unsigned short        whichCol;                // Index into the scan line data of where to place the next data bytes
  2423.     unsigned short        x;                            
  2424.     unsigned long        tempColumn;                // Placeholder for the column of data we're currently assembling
  2425.                                                         //    for 72 dpi:     only high order byte is used
  2426.                                                         //    for 216 dpi:    highest order three bytes are used
  2427.     Ptr                    basePtr;                    // Pointer to current X byte
  2428.     unsigned char        outputMask;                // Mask of bit to set in rotated image
  2429.     unsigned char        inputMask;                // Mask of bit to look at in X
  2430.     unsigned short        yPointerOffset;        // Increment pointer by this to get to next scanline
  2431.     unsigned short        endY;                        //    Last scan line to examine (top-to-bottom)
  2432.     unsigned short        endX;                        //    Last pixel column to examine (left-to-right)
  2433.     unsigned short        incrY;                    //    Number of scan lines to increment by when advancing to the next scan line
  2434.     short                    bytesPerBand;            //    Number of bytes in a single band (1 for 72 dpi, 3 for 216 dpi)
  2435.             
  2436.  
  2437.     // Determine the number of bytes that are in a single band 
  2438.     if ( (*imageData)->hImageRes == ff(72) )    //    T => Low resolution output
  2439.         bytesPerBand = 1;
  2440.     else
  2441.         bytesPerBand = 3;
  2442.     
  2443.     //    Overlay a scan line structure on the buffer we're filling in 
  2444.     pTheScanLine = (ScanLinePtr) (buffer + *bufferPos);
  2445.     
  2446.     // Set color mode for this scan line, if needed 
  2447.     
  2448.     pTheScanLine->cColorEscape = kEscape;
  2449.     pTheScanLine->cSetColorCommand = kSetColorCommand;
  2450.     
  2451.     if ( (*imageData)->packagingInfo.colorPasses == 4 )    //    T => Doing four pass color output
  2452.     {
  2453.         switch (whatToPackage->colorBand)    //    Determine which color to select
  2454.         {
  2455.             case 1: // yellow
  2456.                 pTheScanLine->cColor    = '1';
  2457.                 break;
  2458.                 
  2459.             case 2: // magenta
  2460.                 pTheScanLine->cColor    = '2';
  2461.                 break;
  2462.  
  2463.             case 3: // cyan
  2464.                 pTheScanLine->cColor    = '3';
  2465.                 break;
  2466.                 
  2467.             case 4: // black
  2468.                 pTheScanLine->cColor    = '0';
  2469.                 break;
  2470.         }
  2471.     }
  2472.     else    //    T => Just doing black and white printing; select the color black
  2473.         pTheScanLine->cColor = '0';
  2474.  
  2475.     // We start out with no dirty bits
  2476.     firstDirty = 0;
  2477.     bandIsDirty = false;
  2478.     
  2479.     // Set our array index to zero
  2480.     whichCol = 0;
  2481.     
  2482.     // Get the byte pointer for the start of this color band
  2483.     basePtr = whatToPackage->bitmapToPackage->image;
  2484.     
  2485.     // Get the byte pointer for the start of the first scan line
  2486.     basePtr += whatToPackage->startRaster * whatToPackage->bitmapToPackage->rowBytes;
  2487.             
  2488.     // Save away loop invariants
  2489.     
  2490.     endY = whatToPackage->startRaster + (*imageData)->packagingInfo.headHeight;    // Ending Y scan line
  2491.     incrY = (*imageData)->packagingInfo.passOffset + 1;                                    // Number of scanlines to increment by
  2492.     endX = whatToPackage->dirtyRect.right;                                                        // Ending X pos
  2493.     yPointerOffset = incrY * whatToPackage->bitmapToPackage->rowBytes;                // amount to add to the input pointer to move to the next scanline
  2494.  
  2495.     // If the ending position is too large for the bitmap we have been given,
  2496.     //truncate it, so that we don't print garbage
  2497.  
  2498.     if (endY > whatToPackage->bitmapToPackage->height)
  2499.          endY = whatToPackage->bitmapToPackage->height;
  2500.     
  2501.     // Start with the first bit in the byte sub-band
  2502.     inputMask = 0x80;
  2503.  
  2504.     // For the entire width of the scan line, move a rolling mask along in the
  2505.     // X direction, rotating up 8 or 24 bits of Y data per column.
  2506.     
  2507.     for (x = 0; x < endX; x++)
  2508.     {        
  2509.         Ptr    thePtr;
  2510.  
  2511.         // The bits in this column are clear to begin with
  2512.         tempColumn = 0;
  2513.         
  2514.         // Which byte(s) to look at in the input buffer
  2515.         thePtr = basePtr;
  2516.         
  2517.         // For the number of bytes in a single band, scan through each single  
  2518.         // byte sub-band, setting each of the 8 bits = the bit in that scan line
  2519.         {
  2520.             short                    bitsPerByte;
  2521.             short                    byteSubBand = bytesPerBand;
  2522.             unsigned char        *currByte = (unsigned char *) &tempColumn;
  2523.             short                    currYPos;
  2524.             
  2525.             currYPos = whatToPackage->startRaster;
  2526.             
  2527.             do
  2528.             {
  2529.                 // Where to place the bit in the output. The LQ takes the bit pattern upside down.
  2530.                 outputMask = 0x01;
  2531.         
  2532.                 bitsPerByte = 8;
  2533.                 while ( (bitsPerByte > 0) && (currYPos < endY) )
  2534.                 {
  2535.                     // If we have a bit turned on in the input, rotate it into the output
  2536.                     if ( ((*thePtr) & inputMask) != 0 )
  2537.                         *currByte |= outputMask;
  2538.         
  2539.                     // move onto next position in the output data                
  2540.                     outputMask <<= 1;
  2541.                     
  2542.                     // move onto the next scan line in the input data
  2543.                     thePtr += yPointerOffset;
  2544.                     
  2545.                     // Indicate we processed one of the bits
  2546.                     bitsPerByte--;
  2547.                     
  2548.                     // Keep track of our Y position as we move down the column
  2549.                     currYPos += incrY;
  2550.                 }
  2551.                 
  2552.                 if (currYPos >= endY)    //    T => We're done with this column
  2553.                     break;
  2554.                     
  2555.                 // Indicate we processed one of the byte rows in the band
  2556.                 byteSubBand--;
  2557.                 
  2558.                 // Bump to the next byte to fill in tempColumn
  2559.                 currByte++;
  2560.             }
  2561.             while (byteSubBand > 0);
  2562.         }
  2563.             
  2564.         // Save the column info (a max. of three bytes). Note: we'll only advance whichCol based upon the number of bytes per band
  2565.         BlockMove((Ptr) &tempColumn, (Ptr) &(pTheScanLine->iTheData[whichCol]), 3);
  2566.         
  2567.         // If we have some form of data, then mark that this band is dirty
  2568.         if (tempColumn != 0)
  2569.         {
  2570.             if (!bandIsDirty)    //    T => Not already dirty; remember the first dirty pixel
  2571.             {
  2572.                 /* These are the first dirty pixels we have seen so far */
  2573.                 bandIsDirty = true;
  2574.                 firstDirty = x;
  2575.             }
  2576.         }
  2577.             
  2578.         // If we have some dirty bits, adjust the whichCol variable based upon the number of bytes in a band
  2579.         if (bandIsDirty)
  2580.         {
  2581.             // Move on to the next column or set of columns
  2582.             whichCol += bytesPerBand;
  2583.         }
  2584.  
  2585.         // Position for the next bit in the input byte currently referenced by basePtr
  2586.         inputMask >>= 1;
  2587.         
  2588.         if (inputMask == 0)    //    T => Need to reset the input mask and advance the pointer
  2589.         {
  2590.             // Get the next byte
  2591.             basePtr++;
  2592.             
  2593.             // Reset the bit mask to the first bit
  2594.             inputMask = 0x80;
  2595.         }
  2596.     } // end of loop for width of bitmap
  2597.  
  2598.     // If we have a dirty band, fill in the left margin setting and add a carriage return to the end
  2599.     if (bandIsDirty)
  2600.     {            
  2601.         // Set the left margin to be the first dirty pixel in the scan line
  2602.         {
  2603.             SpecGlobalsHdl     hGlobals = GetMessageHandlerInstanceContext();
  2604.             
  2605.             check(hGlobals);
  2606.             
  2607.             // Stuff in the set margin command
  2608.             
  2609.             pTheScanLine->cMarginsEscape = kEscape;
  2610.             pTheScanLine->cMarginsCommand = (bytesPerBand == 1) ? kLowResMarginsCommand : kHighResMarginsCommand;
  2611.             
  2612.             // Convert left margin into ASCII and place it at the start of the scan line
  2613.             Long2Dec((*hGlobals)->leftMargin + firstDirty, (Ptr) (pTheScanLine->cIndentDistance));
  2614.         }
  2615.         
  2616.         // Now fill in the last escape sequence command depending upon if we're doing low-res or high-res graphics
  2617.         
  2618.         pTheScanLine->cEscape = kEscape;
  2619.         pTheScanLine->cCommand = (bytesPerBand == 1)    ? kLowResGraphicsCommand : kHighResGraphicsCommand;
  2620.  
  2621.         // If we're doing high-res, then whichCol must be divided by three to compensate for the 3-byte buffer entries
  2622.         {
  2623.             short        adjustedWhichCol = whichCol;
  2624.             
  2625.             if (bytesPerBand == 3)
  2626.                 adjustedWhichCol /= 3;
  2627.                 
  2628.             Long2Dec(adjustedWhichCol, (Ptr) (pTheScanLine->cLineStrLength));
  2629.         }
  2630.         
  2631.         
  2632.         //    Increment the count of the number of bytes that have been added to the buffer
  2633.         *bufferPos += kScanLineHdrSize + whichCol;
  2634.  
  2635.         // Lastly, put a <cr> at the end of the line
  2636.         *(buffer + *bufferPos) = '\n';
  2637.         *bufferPos += 1;
  2638.     }
  2639.         
  2640.     return(anErr);
  2641. }
  2642. /* SD_RasterPackageBitmap */
  2643.  
  2644.  
  2645. /****************************************************************************************
  2646.  
  2647.                             SD_RasterLineFeed
  2648.                             
  2649.     function:
  2650.                 This routine is called by the Printing Manager to send the appropriate line
  2651.                 feed commands to the printer i norder to skip up or down the page the 
  2652.                 equivalent of lineFeedSize pixels.
  2653.                 
  2654.     parameters:    
  2655.                 lineFeedSize    number of pixels to line feed by
  2656.                 buffer            buffer in which to place the linefeed packaging commands
  2657.                 bufferPos        offset within buffer at which to place the linefeed commands
  2658.                 imageData        handle to the raster image data
  2659.                 
  2660.     returns:
  2661.                 OSErr
  2662.  
  2663. ****************************************************************************************/
  2664. OSErr SD_RasterLineFeed(short                     *lineFeedSize, 
  2665.                                 Ptr                         buffer, 
  2666.                                 unsigned long            *bufferPos, 
  2667.                                 gxRasterImageDataHdl    imageData)
  2668. {
  2669.     OSErr        anErr = noErr;
  2670.     
  2671.     // If there is no need for any line feeds, then just return now
  2672.     if (*lineFeedSize == 0)
  2673.         return(anErr);
  2674.         
  2675.     // If we are in low res mode, we double the line feed size, as all ImageWriter LQ 
  2676.     // line feed commands are expressed at 144 dpi.
  2677.     if ( (*imageData)->vImageRes == ff(72) )
  2678.     {
  2679.         long    longLineFeedSize;
  2680.         *lineFeedSize <<= 1;
  2681.         
  2682.         // do the line feed in the default way
  2683.         longLineFeedSize = *lineFeedSize;
  2684.         anErr = Forward_GXRasterLineFeed(&longLineFeedSize, buffer, bufferPos, imageData);
  2685.         *lineFeedSize = longLineFeedSize;
  2686.         
  2687.         *lineFeedSize >>= 1;
  2688.     }
  2689.     else    //    T => In high res. mode; must determine the number of 1/144 inch and 1/216 inch line feeds needed
  2690.     {
  2691.         Ptr        nextByte;    
  2692.         Fixed        lineFeedInInches;
  2693.         Fixed        oneOver144;
  2694.         Fixed        remainder;
  2695.         short        num216FractLineFeeds;
  2696.         Fixed        num144FractLineFeeds;
  2697.         Str31        aNumber;
  2698.                         
  2699.         // Determine the location at which we'll begin inserting commands
  2700.         nextByte = buffer + *bufferPos;
  2701.         
  2702.         // Is line feed movement going to be backward?
  2703.         if ( *lineFeedSize < 0 )
  2704.         {
  2705.             *lineFeedSize = -(*lineFeedSize);    // Force positive
  2706.             
  2707.             // Add the backward direction command to the buffer
  2708.             *nextByte++ = kEscape;
  2709.             *nextByte++ = 'r';
  2710.         }
  2711.         else    //    T => Paper motion is forward
  2712.         {
  2713.             // Add the forward direction command to the buffer
  2714.             *nextByte++ = kEscape;
  2715.             *nextByte++ = 'f';
  2716.         }
  2717.         
  2718.         // Update the count of the number of bytes added to the buffer
  2719.         *bufferPos += 2;
  2720.         
  2721.         // Determine the number of inches we need to skip with the line feed command
  2722.         lineFeedInInches = FixDiv( IntToFixed(*lineFeedSize), ff(216) );
  2723.         
  2724.         // Determine the integral number of 1/144 inch increments the line feed space comprises
  2725.         
  2726.         oneOver144 = FixDiv(ff(1), ff(144));
  2727.         num144FractLineFeeds = FixDiv( lineFeedInInches, oneOver144 );
  2728.         
  2729.         // Determine the remaining 1/216 inch line feeds we'll need to add to the buffer
  2730.         
  2731.         remainder = lineFeedInInches - FixMul( IntToFixed( FixedToInt(num144FractLineFeeds) ), oneOver144 );
  2732.         num216FractLineFeeds = FixedToInt( FixDiv( remainder, FixDiv( ff(1), ff(216) ) ) );
  2733.         
  2734.         // Send the line feed spacing commands and the line feeds necessary for the 1/144th's portion of the movement
  2735.         {
  2736.             short        numOne144ths = FixedToInt(num144FractLineFeeds);
  2737.             
  2738.             if (numOne144ths >= 99)    //    T => We can do a max. of 99/144 inch movement at a time
  2739.             {
  2740.                 //    Add the line feed spacing command to the buffer
  2741.                 *nextByte++ = kEscape;
  2742.                 *nextByte++ = 'T';
  2743.                 *nextByte++ = '9';
  2744.                 *nextByte++ = '9';
  2745.                 
  2746.                 // Update the count of the number of bytes added to the buffer
  2747.                 *bufferPos += 4;
  2748.         
  2749.                 do
  2750.                 {
  2751.                     *nextByte++ = kLineFeed;        // line feed
  2752.                     
  2753.                     // Update the count of the number of bytes added to the buffer
  2754.                     *bufferPos += 1;
  2755.         
  2756.                     numOne144ths -= 99;
  2757.                 }
  2758.                 while (numOne144ths >= 99);
  2759.             }
  2760.                 
  2761.             // Send remaining line feeds to finish off the 1/144th's portion of the movement
  2762.  
  2763.             if (numOne144ths > 0)    //    T => Still more movement
  2764.             {
  2765.                 *nextByte++ = kEscape;
  2766.                 *nextByte++ = 'T';
  2767.                 
  2768.                 NumToString(numOne144ths, (unsigned char *) aNumber);
  2769.                 if ( StrLength(aNumber) == 1 )
  2770.                 {
  2771.                     *nextByte++ = '0';
  2772.                     *nextByte++ = aNumber[1];
  2773.                 }
  2774.                 else
  2775.                 {
  2776.                     *nextByte++ = aNumber[1];
  2777.                     *nextByte++ = aNumber[2];
  2778.                 }
  2779.                 
  2780.                 // Add the linefeed character
  2781.                 *nextByte++ = kLineFeed;
  2782.  
  2783.                 // Update the count of the number of bytes added to the buffer
  2784.                 *bufferPos += 5;
  2785.             }
  2786.         }
  2787.         
  2788.         // Now send any spacing command for the remaining 1/216th portion of the movement if needed
  2789.         if (num216FractLineFeeds > 0)
  2790.         {
  2791.             NumToString(num216FractLineFeeds, (unsigned char *) aNumber);
  2792.             
  2793.             // Add the command to the buffer: <Esc> t <num line feeds>
  2794.             
  2795.             *nextByte++ = kEscape;
  2796.             *nextByte++ = 't';
  2797.             *nextByte = aNumber[1];
  2798.             
  2799.             // Bump the buffer byte count to account for these new characters
  2800.             *bufferPos += 3;
  2801.         }
  2802.  
  2803.         // We always handle the entire linefeed request so we can zero lineFeedSize
  2804.         *lineFeedSize = 0;
  2805.     }
  2806.  
  2807.     return(anErr);
  2808. }
  2809. /* SD_RasterLineFeed */
  2810.  
  2811.  
  2812.